taosdata/TDengine | Build 4882 | source/dnode/mnode/impl/src/mndDb.c | Coveralls

73

int32_t mndInitDb(SMnode *pMnode) {

501,119✔

74

  SSdbTable table = {

501,119✔

85

  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbReq);

501,119✔

86

  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);

501,119✔

87

  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);

501,119✔

88

  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);

501,119✔

89

  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);

501,119✔

90

  mndSetMsgHandle(pMnode, TDMT_MND_SCAN_DB, mndProcessScanDbReq);

501,119✔

91

  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);

501,119✔

92

  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB_WAL, mndProcessTrimDbWalReq);

501,119✔

93

  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);

501,119✔

94

  mndSetMsgHandle(pMnode, TDMT_MND_SSMIGRATE_DB, mndProcessSsMigrateDbReq);

501,119✔

95

  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);

501,119✔

97

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);

501,119✔

98

  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);

501,119✔

100

  return sdbSetTable(pMnode->pSdb, table);

501,119✔

103

void mndCleanupDb(SMnode *pMnode) {}

501,002✔

105

SSdbRaw *mndDbActionEncode(SDbObj *pDb) {

6,062,522✔

106

  int32_t code = 0;

6,062,522✔

107

  int32_t lino = 0;

6,062,522✔

108

  terrno = TSDB_CODE_OUT_OF_MEMORY;

6,062,522✔

110

  int32_t  size = sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + DB_RESERVE_SIZE;

6,062,522✔

111

  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, DB_VER_NUMBER, size);

6,062,522✔

112

  if (pRaw == NULL) goto _OVER;

6,062,522✔

114

  int32_t dataPos = 0;

6,062,522✔

115

  SDB_SET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)

6,062,522✔

116

  SDB_SET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)

6,062,522✔

117

  SDB_SET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)

6,062,522✔

118

  SDB_SET_INT64(pRaw, dataPos, pDb->createdTime, _OVER)

6,062,522✔

119

  SDB_SET_INT64(pRaw, dataPos, pDb->updateTime, _OVER)

6,062,522✔

120

  SDB_SET_INT64(pRaw, dataPos, pDb->uid, _OVER)

6,062,522✔

121

  SDB_SET_INT32(pRaw, dataPos, pDb->cfgVersion, _OVER)

6,062,522✔

122

  SDB_SET_INT32(pRaw, dataPos, pDb->vgVersion, _OVER)

6,062,522✔

123

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfVgroups, _OVER)

6,062,522✔

124

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfStables, _OVER)

6,062,522✔

125

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.buffer, _OVER)

6,062,522✔

126

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pageSize, _OVER)

6,062,522✔

127

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.pages, _OVER)

6,062,522✔

128

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheLastSize, _OVER)

6,062,522✔

129

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile, _OVER)

6,062,522✔

130

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0, _OVER)

6,062,522✔

131

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1, _OVER)

6,062,522✔

132

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep2, _OVER)

6,062,522✔

133

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.minRows, _OVER)

6,062,522✔

134

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRows, _OVER)

6,062,522✔

135

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walFsyncPeriod, _OVER)

6,062,522✔

136

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel, _OVER)

6,062,522✔

137

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision, _OVER)

6,062,522✔

138

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression, _OVER)

6,062,522✔

139

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications, _OVER)

6,062,522✔

140

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.strict, _OVER)

6,062,522✔

141

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLast, _OVER)

6,062,522✔

142

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.hashMethod, _OVER)

6,062,522✔

143

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.numOfRetensions, _OVER)

6,062,522✔

144

  for (int32_t i = 0; i < pDb->cfg.numOfRetensions; ++i) {

6,062,522✔

151

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.schemaless, _OVER)

6,062,522✔

152

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRetentionPeriod, _OVER)

6,062,522✔

153

  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walRetentionSize, _OVER)

6,062,522✔

154

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.walRollPeriod, _OVER)

6,062,522✔

155

  SDB_SET_INT64(pRaw, dataPos, pDb->cfg.walSegmentSize, _OVER)

6,062,522✔

156

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.sstTrigger, _OVER)

6,062,522✔

157

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashPrefix, _OVER)

6,062,522✔

158

  SDB_SET_INT16(pRaw, dataPos, pDb->cfg.hashSuffix, _OVER)

6,062,522✔

159

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.tsdbPageSize, _OVER)

6,062,522✔

160

  SDB_SET_INT64(pRaw, dataPos, pDb->compactStartTime, _OVER)

6,062,522✔

161

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.keepTimeOffset, _OVER)

6,062,522✔

162

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.ssChunkSize, _OVER)

6,062,522✔

163

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.ssKeepLocal, _OVER)

6,062,522✔

164

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.ssCompact, _OVER)

6,062,522✔

165

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.withArbitrator, _OVER)

6,062,522✔

166

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.encryptAlgorithm, _OVER)

6,062,522✔

167

  SDB_SET_INT32(pRaw, dataPos, pDb->tsmaVersion, _OVER);

6,062,522✔

168

  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compactTimeOffset, _OVER)

6,062,522✔

169

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactStartTime, _OVER)

6,062,522✔

170

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactEndTime, _OVER)

6,062,522✔

171

  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.compactInterval, _OVER)

6,062,522✔

173

  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

6,062,522✔

174

  SDB_SET_UINT8(pRaw, dataPos, pDb->cfg.flags, _OVER)

6,062,522✔

175

  SDB_SET_DATALEN(pRaw, dataPos, _OVER)

6,062,522✔

177

  terrno = 0;

6,062,522✔

179

_OVER:

6,062,522✔

180

  if (terrno != 0) {

6,062,522✔

186

  mTrace("db:%s, encode to raw:%p, row:%p", pDb->name, pRaw, pDb);

6,062,522✔

187

  return pRaw;

6,062,522✔

190

static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {

5,633,546✔

191

  int32_t code = 0;

5,633,546✔

192

  int32_t lino = 0;

5,633,546✔

193

  terrno = TSDB_CODE_OUT_OF_MEMORY;

5,633,546✔

194

  SSdbRow *pRow = NULL;

5,633,546✔

195

  SDbObj  *pDb = NULL;

5,633,546✔

197

  int8_t sver = 0;

5,633,546✔

198

  if (sdbGetRawSoftVer(pRaw, &sver) != 0) goto _OVER;

5,633,546✔

200

  if (sver != DB_VER_NUMBER) {

5,633,546✔

205

  pRow = sdbAllocRow(sizeof(SDbObj));

5,633,546✔

206

  if (pRow == NULL) goto _OVER;

5,633,546✔

208

  pDb = sdbGetRowObj(pRow);

5,633,546✔

209

  if (pDb == NULL) goto _OVER;

5,633,546✔

211

  int32_t dataPos = 0;

5,633,546✔

212

  SDB_GET_BINARY(pRaw, dataPos, pDb->name, TSDB_DB_FNAME_LEN, _OVER)

5,633,546✔

213

  SDB_GET_BINARY(pRaw, dataPos, pDb->acct, TSDB_USER_LEN, _OVER)

5,633,546✔

214

  SDB_GET_BINARY(pRaw, dataPos, pDb->createUser, TSDB_USER_LEN, _OVER)

5,633,546✔

215

  SDB_GET_INT64(pRaw, dataPos, &pDb->createdTime, _OVER)

5,633,546✔

216

  SDB_GET_INT64(pRaw, dataPos, &pDb->updateTime, _OVER)

5,633,546✔

217

  SDB_GET_INT64(pRaw, dataPos, &pDb->uid, _OVER)

5,633,546✔

218

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfgVersion, _OVER)

5,633,546✔

219

  SDB_GET_INT32(pRaw, dataPos, &pDb->vgVersion, _OVER)

5,633,546✔

220

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfVgroups, _OVER)

5,633,546✔

221

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfStables, _OVER)

5,633,546✔

222

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.buffer, _OVER)

5,633,546✔

223

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pageSize, _OVER)

5,633,546✔

224

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.pages, _OVER)

5,633,546✔

225

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.cacheLastSize, _OVER)

5,633,546✔

226

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysPerFile, _OVER)

5,633,546✔

227

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep0, _OVER)

5,633,546✔

228

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep1, _OVER)

5,633,546✔

229

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.daysToKeep2, _OVER)

5,633,546✔

230

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.minRows, _OVER)

5,633,546✔

231

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.maxRows, _OVER)

5,633,546✔

232

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walFsyncPeriod, _OVER)

5,633,546✔

233

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.walLevel, _OVER)

5,633,546✔

234

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.precision, _OVER)

5,633,546✔

235

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compression, _OVER)

5,633,546✔

236

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.replications, _OVER)

5,633,546✔

237

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.strict, _OVER)

5,633,546✔

238

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.cacheLast, _OVER)

5,633,546✔

239

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.hashMethod, _OVER)

5,633,546✔

240

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.numOfRetensions, _OVER)

5,633,546✔

241

  if (pDb->cfg.numOfRetensions > 0) {

5,633,546✔

255

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.schemaless, _OVER)

5,633,546✔

256

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRetentionPeriod, _OVER)

5,633,546✔

257

  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walRetentionSize, _OVER)

5,633,546✔

258

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.walRollPeriod, _OVER)

5,633,546✔

259

  SDB_GET_INT64(pRaw, dataPos, &pDb->cfg.walSegmentSize, _OVER)

5,633,546✔

260

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.sstTrigger, _OVER)

5,633,546✔

261

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashPrefix, _OVER)

5,633,546✔

262

  SDB_GET_INT16(pRaw, dataPos, &pDb->cfg.hashSuffix, _OVER)

5,633,546✔

263

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.tsdbPageSize, _OVER)

5,633,546✔

264

  SDB_GET_INT64(pRaw, dataPos, &pDb->compactStartTime, _OVER)

5,633,546✔

265

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.keepTimeOffset, _OVER)

5,633,546✔

266

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.ssChunkSize, _OVER)

5,633,546✔

267

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.ssKeepLocal, _OVER)

5,633,546✔

268

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.ssCompact, _OVER)

5,633,546✔

269

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.withArbitrator, _OVER)

5,633,546✔

270

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.encryptAlgorithm, _OVER)

5,633,546✔

271

  SDB_GET_INT32(pRaw, dataPos, &pDb->tsmaVersion, _OVER);

5,633,546✔

272

  SDB_GET_INT8(pRaw, dataPos, &pDb->cfg.compactTimeOffset, _OVER)

5,633,546✔

273

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactStartTime, _OVER)

5,633,546✔

274

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactEndTime, _OVER)

5,633,546✔

275

  SDB_GET_INT32(pRaw, dataPos, &pDb->cfg.compactInterval, _OVER)

5,633,546✔

276

  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

5,633,546✔

277

  if (dataPos + sizeof(uint8_t) <= pRaw->dataLen) {

5,633,546✔

278

    SDB_GET_UINT8(pRaw, dataPos, &pDb->cfg.flags, _OVER)

5,633,546✔

281

  taosInitRWLatch(&pDb->lock);

5,633,546✔

283

  if (pDb->cfg.ssChunkSize == 0) {

5,633,546✔

289

  if (pDb->cfg.ssKeepLocal == 0) {

5,633,546✔

295

  if (pDb->cfg.tsdbPageSize != TSDB_MIN_TSDB_PAGESIZE) {

5,633,546✔

296

    mInfo("db:%s, tsdbPageSize set from %d to default %d", pDb->name, pDb->cfg.tsdbPageSize,

5,633,546✔

300

  if (pDb->cfg.sstTrigger != TSDB_MIN_STT_TRIGGER) {

5,633,546✔

301

    mInfo("db:%s, sstTrigger set from %d to default %d", pDb->name, pDb->cfg.sstTrigger, TSDB_DEFAULT_SST_TRIGGER);

5,525,480✔

304

  terrno = 0;

5,633,546✔

306

_OVER:

5,633,546✔

307

  if (terrno != 0) {

5,633,546✔

313

  mTrace("db:%s, decode from raw:%p, row:%p", pDb->name, pRaw, pDb);

5,633,546✔

314

  return pRow;

5,633,546✔

317

static int32_t mndNewDbActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *pRaw) {

1,270,509✔

318

  SSdb    *pSdb = pMnode->pSdb;

1,270,509✔

319

  SSdbRow *pRow = NULL;

1,270,509✔

320

  SDbObj  *pNewDb = NULL;

1,270,509✔

321

  int      code = -1;

1,270,509✔

323

  pRow = mndDbActionDecode(pRaw);

1,270,509✔

324

  if (pRow == NULL) {

1,270,509✔

329

  pNewDb = sdbGetRowObj(pRow);

1,270,509✔

330

  if (pNewDb == NULL) {

1,270,509✔

336

  SDbObj *pOldDb = sdbAcquire(pMnode->pSdb, SDB_DB, pNewDb->name);

1,270,509✔

337

  if (pOldDb != NULL) {

1,270,509✔

345

  code = 0;

1,270,509✔

346

_OVER:

1,270,509✔

347

  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);

1,270,509✔

348

  taosMemoryFreeClear(pRow);

1,270,509✔

349

  return code;

1,270,509✔

352

static int32_t mndDbActionInsert(SSdb *pSdb, SDbObj *pDb) {

1,447,024✔

353

  mTrace("db:%s, perform insert action, row:%p", pDb->name, pDb);

1,447,024✔

354

  return 0;

1,447,024✔

357

static int32_t mndDbActionDelete(SSdb *pSdb, SDbObj *pDb) {

5,633,546✔

358

  mTrace("db:%s, perform delete action, row:%p", pDb->name, pDb);

5,633,546✔

359

  taosArrayDestroy(pDb->cfg.pRetensions);

5,633,546✔

360

  return 0;

5,633,546✔

363

static int32_t mndDbActionUpdate(SSdb *pSdb, SDbObj *pOld, SDbObj *pNew) {

2,204,878✔

364

  mTrace("db:%s, perform update action, old row:%p new row:%p", pOld->name, pOld, pNew);

2,204,878✔

365

  taosWLockLatch(&pOld->lock);

2,204,878✔

366

  pOld->updateTime = pNew->updateTime;

2,204,878✔

367

  pOld->cfgVersion = pNew->cfgVersion;

2,204,878✔

368

  pOld->vgVersion = pNew->vgVersion;

2,204,878✔

369

  pOld->cfg.numOfVgroups = pNew->cfg.numOfVgroups;

2,204,878✔

370

  pOld->cfg.buffer = pNew->cfg.buffer;

2,204,878✔

371

  pOld->cfg.pageSize = pNew->cfg.pageSize;

2,204,878✔

372

  pOld->cfg.pages = pNew->cfg.pages;

2,204,878✔

373

  pOld->cfg.cacheLastSize = pNew->cfg.cacheLastSize;

2,204,878✔

374

  pOld->cfg.daysPerFile = pNew->cfg.daysPerFile;

2,204,878✔

375

  pOld->cfg.daysToKeep0 = pNew->cfg.daysToKeep0;

2,204,878✔

376

  pOld->cfg.daysToKeep1 = pNew->cfg.daysToKeep1;

2,204,878✔

377

  pOld->cfg.daysToKeep2 = pNew->cfg.daysToKeep2;

2,204,878✔

378

  pOld->cfg.keepTimeOffset = pNew->cfg.keepTimeOffset;

2,204,878✔

379

  pOld->cfg.walFsyncPeriod = pNew->cfg.walFsyncPeriod;

2,204,878✔

380

  pOld->cfg.walLevel = pNew->cfg.walLevel;

2,204,878✔

381

  pOld->cfg.walRetentionPeriod = pNew->cfg.walRetentionPeriod;

2,204,878✔

382

  pOld->cfg.walRetentionSize = pNew->cfg.walRetentionSize;

2,204,878✔

383

  pOld->cfg.strict = pNew->cfg.strict;

2,204,878✔

384

  pOld->cfg.cacheLast = pNew->cfg.cacheLast;

2,204,878✔

385

  pOld->cfg.replications = pNew->cfg.replications;

2,204,878✔

386

  pOld->cfg.sstTrigger = pNew->cfg.sstTrigger;

2,204,878✔

387

  pOld->cfg.minRows = pNew->cfg.minRows;

2,204,878✔

388

  pOld->cfg.maxRows = pNew->cfg.maxRows;

2,204,878✔

389

  pOld->cfg.tsdbPageSize = pNew->cfg.tsdbPageSize;

2,204,878✔

390

  pOld->cfg.ssChunkSize = pNew->cfg.ssChunkSize;

2,204,878✔

391

  pOld->cfg.ssKeepLocal = pNew->cfg.ssKeepLocal;

2,204,878✔

392

  pOld->cfg.ssCompact = pNew->cfg.ssCompact;

2,204,878✔

393

  pOld->cfg.withArbitrator = pNew->cfg.withArbitrator;

2,204,878✔

394

  pOld->cfg.compactInterval = pNew->cfg.compactInterval;

2,204,878✔

395

  pOld->cfg.compactStartTime = pNew->cfg.compactStartTime;

2,204,878✔

396

  pOld->cfg.compactEndTime = pNew->cfg.compactEndTime;

2,204,878✔

397

  pOld->cfg.compactTimeOffset = pNew->cfg.compactTimeOffset;

2,204,878✔

398

  pOld->compactStartTime = pNew->compactStartTime;

2,204,878✔

399

  pOld->tsmaVersion = pNew->tsmaVersion;

2,204,878✔

400

  taosWUnLockLatch(&pOld->lock);

2,204,878✔

401

  return 0;

2,204,878✔

404

static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {

7,825,483✔

405

  SSdb *pSdb = pMnode->pSdb;

7,825,483✔

406

  return sdbGetTableVer(pSdb, SDB_VGROUP);

7,825,483✔

409

SDbObj *mndAcquireDb(SMnode *pMnode, const char *db) {

77,002,515✔

410

  SSdb   *pSdb = pMnode->pSdb;

77,002,515✔

411

  SDbObj *pDb = sdbAcquire(pSdb, SDB_DB, db);

77,002,515✔

412

  if (pDb == NULL) {

77,002,714✔

413

    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {

2,218,381✔

414

      terrno = TSDB_CODE_MND_DB_NOT_EXIST;

2,078,400✔

415

    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {

139,981✔

416

      terrno = TSDB_CODE_MND_DB_IN_CREATING;

10,805✔

417

    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {

129,176✔

418

      terrno = TSDB_CODE_MND_DB_IN_DROPPING;

129,176✔

424

  return pDb;

77,002,515✔

427

void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {

85,844,836✔

428

  SSdb *pSdb = pMnode->pSdb;

85,844,836✔

429

  sdbRelease(pSdb, pDb);

85,844,836✔

430

85,844,836✔

432

bool mndDbIsExist(SMnode *pMnode, const char *db, int64_t uid) {

137,346✔

433

  SDbObj *pDb = mndAcquireDb(pMnode, db);

137,346✔

434

  if (pDb == NULL) {

137,346✔

435

    return false;

1,388✔

437

    bool result = (uid == 0) || (uid == pDb->uid);

135,958✔

438

    mndReleaseDb(pMnode, pDb);

135,958✔

439

    pDb = NULL;

135,958✔

440

    return result;

135,958✔

444

int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {

1,196,853✔

445

  char *pos = strstr(dbName, TS_PATH_DELIMITER);

1,196,853✔

446

  if (pos == NULL) {

1,196,853✔

450

  int32_t acctId;

1,196,552✔

451

  int32_t code = taosStr2int32(dbName, &acctId);

1,196,853✔

452

  if (code != 0) {

1,196,853✔

456

  if (acctId != pUser->acctId) {

1,196,853✔

460

  return 0;

1,196,853✔

463

int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {

1,196,853✔

464

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

1,196,853✔

466

  if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return code;

1,196,853✔

467

  if (pCfg->numOfStables < TSDB_DB_STREAM_MODE_OFF || pCfg->numOfStables > TSDB_DB_STREAM_MODE_ON) return code;

1,196,853✔

468

  if (pCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;

1,196,853✔

469

  if (pCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;

1,196,853✔

470

  if (pCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;

1,196,853✔

471

  if (pCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;

1,196,853✔

472

  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;

1,196,853✔

473

  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;

1,196,853✔

474

  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;

1,196,853✔

475

  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;

1,196,853✔

476

  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return code;

1,196,853✔

477

  if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return code;

1,196,853✔

478

  if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return code;

1,196,853✔

479

  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return code;

1,196,853✔

480

  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;

1,196,853✔

481

  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;

1,196,853✔

482

  if (pCfg->minRows > pCfg->maxRows) return code;

1,196,853✔

483

  if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;

1,196,087✔

484

  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;

1,196,087✔

485

  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return code;

1,196,087✔

486

  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return code;

1,196,087✔

487

  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return code;

1,196,087✔

489

  if ((pCfg->replications == 2) ^ (pCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;

1,196,087✔

496

  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return code;

1,196,087✔

497

  if (pCfg->schemaless < TSDB_DB_SCHEMALESS_OFF || pCfg->schemaless > TSDB_DB_SCHEMALESS_ON) return code;

1,196,087✔

498

  if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;

1,196,087✔

499

  if (pCfg->hashMethod != 1) return code;

1,196,087✔

500

  if (pCfg->replications > mndGetDnodeSize(pMnode)) {

1,196,087✔

504

  if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;

1,196,087✔

505

  if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;

1,196,087✔

506

  if (pCfg->walRollPeriod < TSDB_DB_MIN_WAL_ROLL_PERIOD) return code;

1,196,087✔

507

  if (pCfg->walSegmentSize < TSDB_DB_MIN_WAL_SEGMENT_SIZE) return code;

1,196,087✔

508

  if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return code;

1,196,087✔

509

  if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return code;

1,196,087✔

510

  if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return code;

1,196,087✔

511

  if ((pCfg->hashSuffix * pCfg->hashPrefix) < 0) return code;

1,196,087✔

512

  if ((pCfg->hashPrefix + pCfg->hashSuffix) >= (TSDB_TABLE_NAME_LEN - 1)) return code;

1,196,087✔

513

  if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return code;

1,196,087✔

514

  if (taosArrayGetSize(pCfg->pRetensions) != pCfg->numOfRetensions) return code;

1,196,087✔

516

  if (pCfg->ssChunkSize < TSDB_MIN_SS_CHUNK_SIZE || pCfg->ssChunkSize > TSDB_MAX_SS_CHUNK_SIZE) return code;

1,196,087✔

517

  if (pCfg->ssKeepLocal < TSDB_MIN_SS_KEEP_LOCAL || pCfg->ssKeepLocal > TSDB_MAX_SS_KEEP_LOCAL) return code;

1,196,087✔

518

  if (pCfg->ssCompact < TSDB_MIN_SS_COMPACT || pCfg->ssCompact > TSDB_MAX_SS_COMPACT) return code;

1,196,087✔

520

  if (pCfg->compactInterval != 0 &&

1,196,087✔

521

      (pCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pCfg->compactInterval > pCfg->daysToKeep2))

4,542✔

523

  if (pCfg->compactStartTime != 0 &&

1,196,087✔

524

      (pCfg->compactStartTime < -pCfg->daysToKeep2 || pCfg->compactStartTime > -pCfg->daysPerFile))

4,587✔

526

  if (pCfg->compactEndTime != 0 &&

1,196,087✔

527

      (pCfg->compactEndTime < -pCfg->daysToKeep2 || pCfg->compactEndTime > -pCfg->daysPerFile))

4,587✔

529

  if (pCfg->compactStartTime != 0 && pCfg->compactEndTime != 0 && pCfg->compactStartTime >= pCfg->compactEndTime)

1,196,087✔

531

  if (pCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET || pCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

1,196,087✔

534

  code = 0;

1,196,087✔

535

  TAOS_RETURN(code);

1,196,087✔

538

static int32_t mndCheckInChangeDbCfg(SMnode *pMnode, SDbCfg *pOldCfg, SDbCfg *pNewCfg) {

82,054✔

539

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

82,054✔

540

  if (pNewCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pNewCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;

82,054✔

541

  if (pNewCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pNewCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;

82,054✔

542

  if (pNewCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pNewCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;

82,054✔

543

  if (pNewCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pNewCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;

82,054✔

544

  if (pNewCfg->daysToKeep0 < TSDB_MIN_KEEP || pNewCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;

82,054✔

545

  if (pNewCfg->daysToKeep1 < TSDB_MIN_KEEP || pNewCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;

82,054✔

546

  if (pNewCfg->daysToKeep2 < TSDB_MIN_KEEP || pNewCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;

82,054✔

547

  if (pNewCfg->daysToKeep0 < pNewCfg->daysPerFile) return code;

82,054✔

548

  if (pNewCfg->daysToKeep0 > pNewCfg->daysToKeep1) return code;

82,054✔

549

  if (pNewCfg->daysToKeep1 > pNewCfg->daysToKeep2) return code;

82,054✔

550

  if (pNewCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pNewCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET)

82,054✔

552

  if (pNewCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pNewCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;

82,054✔

553

  if (pNewCfg->walLevel < TSDB_MIN_WAL_LEVEL || pNewCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;

82,054✔

554

  if (pNewCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pNewCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;

82,054✔

555

  if (pNewCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pNewCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;

82,054✔

556

  if (pNewCfg->replications < TSDB_MIN_DB_REPLICA || pNewCfg->replications > TSDB_MAX_DB_REPLICA) return code;

82,054✔

558

  if ((pNewCfg->replications == 2) ^ (pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;

82,054✔

559

  if (pNewCfg->replications == 2 && pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR) {

82,054✔

560

    if (pOldCfg->replications != 1 && pOldCfg->replications != 2) {

755✔

561

      terrno = TSDB_CODE_OPS_NOT_SUPPORT;

755✔

562

      return code;

755✔

565

  if (pNewCfg->replications != 2 && pOldCfg->replications == 2) {

81,299✔

573

  if (pNewCfg->walLevel == 0 && pOldCfg->replications > 1) {

81,299✔

577

  if (pNewCfg->replications > 1 && pOldCfg->walLevel == 0) {

81,299✔

582

  if (pNewCfg->sstTrigger != pOldCfg->sstTrigger &&

81,299✔

583

      (pNewCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pNewCfg->sstTrigger > TSDB_MAX_STT_TRIGGER))

1,339✔

585

  if (pNewCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pNewCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;

81,299✔

586

  if (pNewCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pNewCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;

81,299✔

587

  if (pNewCfg->minRows > pNewCfg->maxRows) return code;

81,299✔

588

  if (pNewCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;

80,544✔

589

  if (pNewCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;

80,544✔

590

  if (pNewCfg->strict < TSDB_DB_STRICT_OFF || pNewCfg->strict > TSDB_DB_STRICT_ON) return code;

80,544✔

591

  if (pNewCfg->replications > mndGetDnodeSize(pMnode)) {

80,544✔

595

  if (pNewCfg->ssChunkSize < TSDB_MIN_SS_CHUNK_SIZE || pNewCfg->ssChunkSize > TSDB_MAX_SS_CHUNK_SIZE) return code;

80,544✔

596

  if (pNewCfg->ssKeepLocal < TSDB_MIN_SS_KEEP_LOCAL || pNewCfg->ssKeepLocal > TSDB_MAX_SS_KEEP_LOCAL) return code;

80,544✔

597

  if (pNewCfg->ssCompact < TSDB_MIN_SS_COMPACT || pNewCfg->ssCompact > TSDB_MAX_SS_COMPACT) return code;

80,544✔

599

  if (pNewCfg->compactInterval != 0 &&

80,544✔

600

      (pNewCfg->compactInterval < TSDB_MIN_COMPACT_INTERVAL || pNewCfg->compactInterval > pNewCfg->daysToKeep2))

6,897✔

602

  if (pNewCfg->compactStartTime != 0 &&

80,544✔

603

      (pNewCfg->compactStartTime < -pNewCfg->daysToKeep2 || pNewCfg->compactStartTime > -pNewCfg->daysPerFile))

4,632✔

605

  if (pNewCfg->compactEndTime != 0 &&

80,544✔

606

      (pNewCfg->compactEndTime < -pNewCfg->daysToKeep2 || pNewCfg->compactEndTime > -pNewCfg->daysPerFile))

4,632✔

608

  if (pNewCfg->compactStartTime != 0 && pNewCfg->compactEndTime != 0 &&

80,544✔

609

      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)

4,632✔

611

  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||

80,544✔

612

      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

80,544✔

615

  code = 0;

80,544✔

616

  TAOS_RETURN(code);

80,544✔

619

static void mndSetDefaultDbCfg(SDbCfg *pCfg) {

1,195,551✔

620

  if (pCfg->numOfVgroups < 0) pCfg->numOfVgroups = TSDB_DEFAULT_VN_PER_DB;

1,195,551✔

621

  if (pCfg->numOfStables < 0) pCfg->numOfStables = TSDB_DEFAULT_DB_SINGLE_STABLE;

1,195,551✔

622

  if (pCfg->buffer < 0) pCfg->buffer = TSDB_DEFAULT_BUFFER_PER_VNODE;

1,195,551✔

623

  if (pCfg->pageSize < 0) pCfg->pageSize = TSDB_DEFAULT_PAGESIZE_PER_VNODE;

1,195,551✔

624

  if (pCfg->pages < 0) pCfg->pages = TSDB_DEFAULT_PAGES_PER_VNODE;

1,195,551✔

625

  if (pCfg->daysPerFile < 0) pCfg->daysPerFile = TSDB_DEFAULT_DURATION_PER_FILE;

1,195,551✔

626

  if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;

1,195,551✔

627

  if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = pCfg->daysToKeep0;

1,195,551✔

628

  if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = pCfg->daysToKeep1;

1,195,551✔

629

  if (pCfg->keepTimeOffset < 0) pCfg->keepTimeOffset = TSDB_DEFAULT_KEEP_TIME_OFFSET;

1,195,551✔

630

  if (pCfg->minRows < 0) pCfg->minRows = TSDB_DEFAULT_MINROWS_FBLOCK;

1,195,551✔

631

  if (pCfg->maxRows < 0) pCfg->maxRows = TSDB_DEFAULT_MAXROWS_FBLOCK;

1,195,551✔

632

  if (pCfg->walFsyncPeriod < 0) pCfg->walFsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;

1,195,551✔

633

  if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;

1,195,551✔

634

  if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;

1,195,551✔

635

  if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;

1,195,551✔

636

  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA;

1,195,551✔

637

  if (pCfg->strict < 0) pCfg->strict = TSDB_DEFAULT_DB_STRICT;

1,195,551✔

638

  if (pCfg->cacheLast < 0) pCfg->cacheLast = TSDB_DEFAULT_CACHE_MODEL;

1,195,551✔

639

  if (pCfg->cacheLastSize <= 0) pCfg->cacheLastSize = TSDB_DEFAULT_CACHE_SIZE;

1,195,551✔

640

  if (pCfg->numOfRetensions < 0) pCfg->numOfRetensions = 0;

1,195,551✔

641

  if (pCfg->schemaless < 0) pCfg->schemaless = TSDB_DB_SCHEMALESS_OFF;

1,195,551✔

642

  if (pCfg->walRetentionPeriod < 0 && pCfg->walRetentionPeriod != -1)

1,195,551✔

644

  if (pCfg->walRetentionSize < 0 && pCfg->walRetentionSize != -1)

1,195,551✔

646

  if (pCfg->walRollPeriod < 0) pCfg->walRollPeriod = TSDB_REPS_DEF_DB_WAL_ROLL_PERIOD;

1,195,551✔

647

  if (pCfg->walSegmentSize < 0) pCfg->walSegmentSize = TSDB_DEFAULT_DB_WAL_SEGMENT_SIZE;

1,195,551✔

648

  if (pCfg->sstTrigger <= 0) pCfg->sstTrigger = TSDB_DEFAULT_SST_TRIGGER;

1,195,551✔

649

  if (pCfg->tsdbPageSize <= 0) pCfg->tsdbPageSize = TSDB_DEFAULT_TSDB_PAGESIZE;

1,195,551✔

650

  if (pCfg->ssChunkSize <= 0) pCfg->ssChunkSize = TSDB_DEFAULT_SS_CHUNK_SIZE;

1,195,551✔

651

  if (pCfg->ssKeepLocal <= 0) pCfg->ssKeepLocal = TSDB_DEFAULT_SS_KEEP_LOCAL;

1,195,551✔

652

  if (pCfg->ssCompact < 0) pCfg->ssCompact = TSDB_DEFAULT_SS_COMPACT;

1,195,551✔

653

  if (pCfg->withArbitrator < 0) pCfg->withArbitrator = TSDB_DEFAULT_DB_WITH_ARBITRATOR;

1,195,551✔

654

  if (pCfg->encryptAlgorithm < 0) pCfg->encryptAlgorithm = TSDB_DEFAULT_ENCRYPT_ALGO;

1,195,551✔

655

1,195,551✔

657

int32_t mndSetCreateDbPrepareAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

1,190,685✔

658

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

1,190,685✔

659

  if (pDbRaw == NULL) return -1;

1,190,685✔

661

  if (mndTransAppendPrepareLog(pTrans, pDbRaw) != 0) return -1;

1,190,685✔

662

  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_CREATING) != 0) return -1;

1,190,685✔

663

  return 0;

1,190,685✔

666

static int32_t mndSetNewVgPrepareActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

1,189,383✔

667

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

3,692,945✔

668

    if (mndAddNewVgPrepareAction(pMnode, pTrans, (pVgroups + v)) != 0) return -1;

2,503,562✔

670

  return 0;

1,189,383✔

707

static int32_t mndSetCreateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

1,189,383✔

708

  int32_t  code = 0;

1,189,383✔

709

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

1,189,383✔

710

  if (pDbRaw == NULL) {

1,189,383✔

715

  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));

1,189,383✔

716

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));

1,189,383✔

718

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

3,692,945✔

719

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

2,503,562✔

720

    if (pVgRaw == NULL) {

2,503,562✔

725

    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));

2,503,562✔

726

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));

2,503,562✔

729

  if (pDb->cfg.withArbitrator) {

1,189,383✔

730

    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

10,568✔

731

      SVgObj   *pVgObj = pVgroups + v;

6,427✔

732

      SArbGroup arbGroup = {0};

6,427✔

733

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

6,427✔

734

      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));

6,427✔

738

  TAOS_RETURN(code);

1,189,383✔

741

static int32_t mndSetCreateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups,

1,189,383✔

743

  int32_t  code = 0;

1,189,383✔

744

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

1,189,383✔

745

  if (pDbRaw == NULL) {

1,189,383✔

750

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));

1,189,383✔

751

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));

1,189,383✔

753

  for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

3,692,945✔

754

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

2,503,562✔

755

    if (pVgRaw == NULL) {

2,503,562✔

760

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));

2,503,562✔

761

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));

2,503,562✔

764

  if (pDb->cfg.withArbitrator) {

1,189,383✔

765

    for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {

10,568✔

766

      SVgObj   *pVgObj = pVgroups + v;

6,427✔

767

      SArbGroup arbGroup = {0};

6,427✔

768

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

6,427✔

769

      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));

6,427✔

773

  if (pUserDuped) {

1,189,383✔

774

    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);

2,544✔

775

    if (pUserRaw == NULL) {

2,544✔

780

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));

2,544✔

781

    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));

2,544✔

784

  TAOS_RETURN(code);

1,189,383✔

787

static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

1,189,383✔

788

  int32_t code = 0;

1,189,383✔

789

  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {

3,692,945✔

790

    SVgObj *pVgroup = pVgroups + vg;

2,503,562✔

792

    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

5,329,271✔

793

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

2,825,709✔

794

      TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid));

2,825,709✔

798

  TAOS_RETURN(code);

1,189,383✔

801

static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {

1,189,383✔

802

  int32_t code = 0;

1,189,383✔

803

  for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {

3,692,945✔

804

    SVgObj *pVgroup = pVgroups + vg;

2,503,562✔

806

    for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

5,329,271✔

807

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

2,825,709✔

808

      TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false));

2,825,709✔

812

  TAOS_RETURN(code);

1,189,383✔

815

static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser, SArray *dnodeList) {

1,196,346✔

816

  int32_t  code = 0;

1,196,346✔

817

  SUserObj newUserObj = {0};

1,196,346✔

818

  SDbObj   dbObj = {0};

1,196,346✔

819

  (void)memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);

1,196,346✔

820

  (void)memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);

1,196,346✔

821

  dbObj.createdTime = taosGetTimestampMs();

1,196,346✔

822

  dbObj.updateTime = dbObj.createdTime;

1,196,346✔

823

  dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);

1,196,346✔

824

  dbObj.cfgVersion = 1;

1,196,346✔

825

  dbObj.vgVersion = 1;

1,196,346✔

826

  dbObj.tsmaVersion = 1;

1,196,346✔

827

  (void)memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);

1,196,346✔

828

  dbObj.cfg = (SDbCfg){

2,392,391✔

829

      .numOfVgroups = pCreate->numOfVgroups,

1,196,346✔

830

      .numOfStables = pCreate->numOfStables,

1,196,346✔

831

      .buffer = pCreate->buffer,

1,196,346✔

832

      .pageSize = pCreate->pageSize,

1,196,346✔

833

      .pages = pCreate->pages,

1,196,346✔

834

      .cacheLastSize = pCreate->cacheLastSize,

1,196,346✔

835

      .daysPerFile = pCreate->daysPerFile,

1,196,346✔

836

      .daysToKeep0 = pCreate->daysToKeep0,

1,196,346✔

837

      .daysToKeep1 = pCreate->daysToKeep1,

1,196,346✔

838

      .daysToKeep2 = pCreate->daysToKeep2,

1,196,346✔

839

      .keepTimeOffset = pCreate->keepTimeOffset,

1,196,346✔

840

      .minRows = pCreate->minRows,

1,196,346✔

841

      .maxRows = pCreate->maxRows,

1,196,346✔

842

      .walFsyncPeriod = pCreate->walFsyncPeriod,

1,196,346✔

843

      .walLevel = pCreate->walLevel,

1,196,346✔

844

      .precision = pCreate->precision,

1,196,346✔

845

      .compression = pCreate->compression,

1,196,346✔

846

      .replications = pCreate->replications,

1,196,346✔

847

      .strict = pCreate->strict,

1,196,346✔

848

      .cacheLast = pCreate->cacheLast,

1,196,346✔

850

      .schemaless = pCreate->schemaless,

1,196,346✔

851

      .walRetentionPeriod = pCreate->walRetentionPeriod,

1,196,346✔

852

      .walRetentionSize = pCreate->walRetentionSize,

1,196,346✔

853

      .walRollPeriod = pCreate->walRollPeriod,

1,196,346✔

854

      .walSegmentSize = pCreate->walSegmentSize,

1,196,346✔

855

      .sstTrigger = pCreate->sstTrigger,

1,196,346✔

856

      .hashPrefix = pCreate->hashPrefix,

1,196,346✔

857

      .hashSuffix = pCreate->hashSuffix,

1,196,346✔

858

      .ssChunkSize = pCreate->ssChunkSize,

1,196,346✔

859

      .ssKeepLocal = pCreate->ssKeepLocal,

1,196,346✔

860

      .ssCompact = pCreate->ssCompact,

1,196,346✔

861

      .tsdbPageSize = pCreate->tsdbPageSize,

1,196,346✔

862

      .withArbitrator = pCreate->withArbitrator,

1,196,346✔

863

      .encryptAlgorithm = pCreate->encryptAlgorithm,

1,196,346✔

864

      .compactInterval = pCreate->compactInterval,

1,196,346✔

865

      .compactStartTime = pCreate->compactStartTime,

1,196,346✔

866

      .compactEndTime = pCreate->compactEndTime,

1,196,346✔

867

      .compactTimeOffset = pCreate->compactTimeOffset,

1,196,346✔

869

  if (strlen(pCreate->encryptAlgrName) > 0) {

1,196,346✔

870

    if (strncasecmp(pCreate->encryptAlgrName, "none", TSDB_ENCRYPT_ALGR_NAME_LEN) == 0) {

6,160✔

871

      dbObj.cfg.encryptAlgorithm = 0;

4,455✔

873

      SEncryptAlgrObj *pEncryptAlgr = mndAcquireEncryptAlgrByAId(pMnode, pCreate->encryptAlgrName);

1,705✔

874

      if (pEncryptAlgr != NULL) {

1,705✔

875

        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {

910✔

881

        dbObj.cfg.encryptAlgorithm = pEncryptAlgr->id;

910✔

883

        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;

795✔

884

        mError("db:%s, failed to create, encrypt algorithm not exist, %s", pCreate->db, pCreate->encryptAlgrName);

795✔

885

        TAOS_RETURN(code);

795✔

889

  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;

1,195,551✔

890

  dbObj.cfg.pRetensions = pCreate->pRetensions;

1,195,551✔

892

  mndSetDefaultDbCfg(&dbObj.cfg);

1,195,551✔

894

  if ((code = mndCheckDbName(dbObj.name, pUser)) != 0) {

1,195,551✔

899

  if ((code = mndCheckDbCfg(pMnode, &dbObj.cfg)) != 0) {

1,195,551✔

900

    mError("db:%s, failed to create, check db cfg failed, since %s", pCreate->db, tstrerror(code));

766✔

901

    TAOS_RETURN(code);

766✔

904

  if (dbObj.cfg.hashPrefix > 0) {

1,194,785✔

905

    int32_t dbLen = strlen(dbObj.name) + 1;

4,919✔

906

    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix + dbLen);

4,919✔

907

    dbObj.cfg.hashPrefix += dbLen;

4,919✔

908

  } else if (dbObj.cfg.hashPrefix < 0) {

1,189,866✔

909

    int32_t dbLen = strlen(dbObj.name) + 1;

5,015✔

910

    mInfo("db:%s, hashPrefix adjust from %d to %d", dbObj.name, dbObj.cfg.hashPrefix, dbObj.cfg.hashPrefix - dbLen);

5,015✔

911

    dbObj.cfg.hashPrefix -= dbLen;

5,015✔

914

  SVgObj *pVgroups = NULL;

1,194,785✔

915

  if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups, dnodeList)) != 0) {

1,194,785✔

916

    mError("db:%s, failed to create, alloc vgroup failed, since %s", pCreate->db, terrstr());

5,402✔

917

    TAOS_RETURN(code);

5,402✔

921

  SUserObj *pNewUserDuped = NULL;

1,189,383✔

922

  if (!pUser->superUser) {

1,189,383✔

923

    TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);

2,544✔

924

    TAOS_CHECK_GOTO(taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),

2,544✔

926

    TAOS_CHECK_GOTO(taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),

2,544✔

928

    pNewUserDuped = &newUserObj;

2,544✔

931

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "create-db");

1,189,383✔

932

  if (pTrans == NULL) {

1,189,383✔

938

  mInfo("trans:%d, used to create db:%s", pTrans->id, pCreate->db);

1,189,383✔

940

  mndTransSetDbName(pTrans, dbObj.name, NULL);

1,189,383✔

941

  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);

1,189,383✔

943

  void   *pIter = NULL;

1,189,383✔

944

  STrans *exitTrans = NULL;

1,189,383✔

946

  if (!pUser->superUser) {

1,189,383✔

948

      pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&exitTrans);

2,544✔

949

      if (pIter == NULL) break;

2,544✔

963

  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);

1,189,383✔

964

  TAOS_CHECK_GOTO(mndSetCreateDbPrepareAction(pMnode, pTrans, &dbObj), NULL, _OVER);

1,189,383✔

965

  TAOS_CHECK_GOTO(mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

1,189,383✔

966

  TAOS_CHECK_GOTO(mndSetNewVgPrepareActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

1,189,383✔

967

  TAOS_CHECK_GOTO(mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

1,189,383✔

968

  TAOS_CHECK_GOTO(mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups, pNewUserDuped), NULL, _OVER);

1,189,383✔

969

  TAOS_CHECK_GOTO(mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);

1,189,383✔

970

  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);

1,189,383✔

972

_OVER:

1,189,383✔

973

  taosMemoryFree(pVgroups);

1,189,383✔

974

  mndUserFreeObj(&newUserObj);

1,189,383✔

975

  mndTransDrop(pTrans);

1,189,383✔

976

  TAOS_RETURN(code);

1,189,383✔

979

static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {

1,208,538✔

980

  int32_t    code = 0;

1,208,538✔

981

  SSdb      *pSdb = pMnode->pSdb;

1,208,538✔

982

  SDnodeObj *pDnode = NULL;

1,208,538✔

983

  void      *pIter = NULL;

1,208,538✔

986

  if (pReq->encryptAlgorithm == TSDB_ENCRYPT_ALGO_NONE) goto _exit;

1,208,538✔

1017

_exit:

1,208,237✔

1018

  TAOS_RETURN(code);

1,208,538✔

1032

static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {

1,262,286✔

1033

  SMnode      *pMnode = pReq->info.node;

1,262,286✔

1034

  int32_t      code = -1;

1,262,286✔

1035

  int32_t      lino = 0;

1,262,286✔

1036

  SDbObj      *pDb = NULL;

1,262,286✔

1037

  SUserObj    *pUser = NULL;

1,262,286✔

1038

  SCreateDbReq createReq = {0};

1,262,286✔

1039

  SArray      *dnodeList = NULL;

1,262,286✔

1041

  dnodeList = taosArrayInit(mndGetDnodeSize(pMnode), sizeof(int32_t));

1,262,286✔

1042

  TSDB_CHECK_NULL(dnodeList, code, lino, _OVER, TSDB_CODE_OUT_OF_MEMORY);

1,262,286✔

1044

  TAOS_CHECK_GOTO(tDeserializeSCreateDbReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);

1,262,286✔

1051

  mInfo("db:%s, start to create, vgroups:%d", createReq.db, createReq.numOfVgroups);

1,262,286✔

1053

  pDb = mndAcquireDb(pMnode, createReq.db);

1,262,286✔

1054

  if (pDb != NULL) {

1,262,286✔

1055

    if (createReq.ignoreExist) {

43,594✔

1056

      mInfo("db:%s, already exist, ignore exist is set", createReq.db);

40,280✔

1057

      code = 0;

40,280✔

1058

      goto _OVER;

40,280✔

1060

      code = TSDB_CODE_MND_DB_ALREADY_EXIST;

3,314✔

1061

      goto _OVER;

3,314✔

1064

    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {

1,218,692✔

1065

      code = terrno;

9,104✔

1066

      goto _OVER;

9,104✔

1067

    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {

1,209,588✔

1069

    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {

1,209,588✔

1076

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DB, NULL), &lino, _OVER);

1,209,588✔

1078

  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB), &lino, _OVER);

1,208,538✔

1080

  int32_t nVnodes = createReq.numOfVgroups * createReq.replications;

1,208,538✔

1081

  TAOS_CHECK_GOTO(grantCheckEx(TSDB_GRANT_VNODE, &nVnodes), &lino, _OVER);

1,208,538✔

1083

  if (createReq.replications == 2) {

1,208,538✔

1084

    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), &lino, _OVER);

5,665✔

1087

  TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER);

1,208,538✔

1089

  TAOS_CHECK_GOTO(mndCheckDbDnodeList(pMnode, createReq.db, createReq.dnodeListStr, dnodeList), &lino, _OVER);

1,208,538✔

1091

  TAOS_CHECK_GOTO(mndAcquireUser(pMnode, pReq->info.conn.user, &pUser), &lino, _OVER);

1,196,346✔

1093

  if (sdbGetSize(pMnode->pSdb, SDB_MOUNT) > 0) {

1,196,346✔

1097

  TAOS_CHECK_GOTO(mndCreateDb(pMnode, pReq, &createReq, pUser, dnodeList), &lino, _OVER);

1,196,346✔

1098

  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

1,189,383✔

1100

  SName name = {0};

1,189,383✔

1101

  if (tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

1,189,383✔

1104

  auditRecord(pReq, pMnode->clusterId, "createDB", name.dbname, "", createReq.sql, createReq.sqlLen);

1,189,383✔

1106

_OVER:

1,262,286✔

1107

  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {

1,262,286✔

1108

    mError("db:%s, failed to create at line:%d since %s", createReq.db, lino, tstrerror(code));

32,623✔

1111

  mndReleaseDb(pMnode, pDb);

1,262,286✔

1112

  mndReleaseUser(pMnode, pUser);

1,262,286✔

1113

  tFreeSCreateDbReq(&createReq);

1,262,286✔

1114

  taosArrayDestroy(dnodeList);

1,262,286✔

1116

  TAOS_RETURN(code);

1,262,286✔

1119

static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {

105,344✔

1120

  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;

105,344✔

1122

  if (pAlter->buffer > 0 && pAlter->buffer != pDb->cfg.buffer) {

105,344✔

1123

    pDb->cfg.buffer = pAlter->buffer;

4,730✔

1124

    code = 0;

4,730✔

1127

  if (pAlter->pages > 0 && pAlter->pages != pDb->cfg.pages) {

105,344✔

1128

    pDb->cfg.pages = pAlter->pages;

2,385✔

1129

    code = 0;

2,385✔

1132

  if (pAlter->pageSize > 0 && pAlter->pageSize != pDb->cfg.pageSize) {

105,344✔

1137

  if (pAlter->daysPerFile > 0 && pAlter->daysPerFile != pDb->cfg.daysPerFile) {

105,344✔

1142

  if (pAlter->daysToKeep0 > 0 && pAlter->daysToKeep0 != pDb->cfg.daysToKeep0) {

105,344✔

1143

    pDb->cfg.daysToKeep0 = pAlter->daysToKeep0;

15,179✔

1144

    code = 0;

15,179✔

1147

  if (pAlter->daysToKeep1 > 0 && pAlter->daysToKeep1 != pDb->cfg.daysToKeep1) {

105,344✔

1148

    pDb->cfg.daysToKeep1 = pAlter->daysToKeep1;

14,406✔

1149

    code = 0;

14,406✔

1152

  if (pAlter->daysToKeep2 > 0 && pAlter->daysToKeep2 != pDb->cfg.daysToKeep2) {

105,344✔

1153

    pDb->cfg.daysToKeep2 = pAlter->daysToKeep2;

11,970✔

1154

    code = 0;

11,970✔

1157

  if (pAlter->keepTimeOffset >= 0 && pAlter->keepTimeOffset != pDb->cfg.keepTimeOffset) {

105,344✔

1158

    pDb->cfg.keepTimeOffset = pAlter->keepTimeOffset;

3,834✔

1159

    code = 0;

3,834✔

1162

  if (pAlter->walFsyncPeriod >= 0 && pAlter->walFsyncPeriod != pDb->cfg.walFsyncPeriod) {

105,344✔

1163

    pDb->cfg.walFsyncPeriod = pAlter->walFsyncPeriod;

9,152✔

1164

    code = 0;

9,152✔

1167

  if (pAlter->walLevel >= 0 && pAlter->walLevel != pDb->cfg.walLevel) {

105,344✔

1168

    pDb->cfg.walLevel = pAlter->walLevel;

9,149✔

1169

    code = 0;

9,149✔

1172

  if (pAlter->strict >= 0 && pAlter->strict != pDb->cfg.strict) {

105,344✔

1181

  if (pAlter->cacheLast >= 0 && pAlter->cacheLast != pDb->cfg.cacheLast) {

105,344✔

1182

    pDb->cfg.cacheLast = pAlter->cacheLast;

11,319✔

1183

    code = 0;

11,319✔

1186

  if (pAlter->cacheLastSize > 0 && pAlter->cacheLastSize != pDb->cfg.cacheLastSize) {

105,344✔

1187

    pDb->cfg.cacheLastSize = pAlter->cacheLastSize;

1,587✔

1188

    code = 0;

1,587✔

1191

  if (pAlter->replications > 0 && pAlter->replications != pDb->cfg.replications) {

105,344✔

1192

    pDb->cfg.replications = pAlter->replications;

7,611✔

1193

    pDb->vgVersion++;

7,611✔

1194

    code = 0;

7,611✔

1197

  if (pAlter->sstTrigger > 0 && pAlter->sstTrigger != pDb->cfg.sstTrigger) {

105,344✔

1198

    pDb->cfg.sstTrigger = pAlter->sstTrigger;

1,339✔

1199

    pDb->vgVersion++;

1,339✔

1200

    code = 0;

1,339✔

1203

  if (pAlter->minRows > 0 && pAlter->minRows != pDb->cfg.minRows) {

105,344✔

1204

    pDb->cfg.minRows = pAlter->minRows;

1,510✔

1205

    pDb->vgVersion++;

1,510✔

1206

    code = 0;

1,510✔

1209

  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&

105,344✔

1210

      pAlter->walRetentionPeriod != pDb->cfg.walRetentionPeriod) {

4,952✔

1211

    pDb->cfg.walRetentionPeriod = pAlter->walRetentionPeriod;

2,322✔

1212

    pDb->vgVersion++;

2,322✔

1213

    code = 0;

2,322✔

1216

  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&

105,344✔

1217

      pAlter->walRetentionSize != pDb->cfg.walRetentionSize) {

1,550✔

1218

    pDb->cfg.walRetentionSize = pAlter->walRetentionSize;

755✔

1219

    pDb->vgVersion++;

755✔

1220

    code = 0;

755✔

1223

  if (pAlter->ssKeepLocal >= TSDB_MIN_SS_KEEP_LOCAL && pAlter->ssKeepLocal <= TSDB_MAX_SS_KEEP_LOCAL && pAlter->ssKeepLocal != pDb->cfg.ssKeepLocal) {

105,344✔

1224

    pDb->cfg.ssKeepLocal = pAlter->ssKeepLocal;

755✔

1225

    pDb->vgVersion++;

755✔

1226

    code = 0;

755✔

1229

  if (pAlter->ssCompact >= TSDB_MIN_SS_COMPACT && pAlter->ssCompact <= TSDB_MAX_SS_COMPACT && pAlter->ssCompact != pDb->cfg.ssCompact) {

105,344✔

1230

    pDb->cfg.ssCompact = pAlter->ssCompact;

755✔

1231

    pDb->vgVersion++;

755✔

1232

    code = 0;

755✔

1235

  if (pAlter->withArbitrator >= TSDB_MIN_DB_WITH_ARBITRATOR && pAlter->withArbitrator != pDb->cfg.withArbitrator) {

105,344✔

1236

    pDb->cfg.withArbitrator = pAlter->withArbitrator;

755✔

1237

    pDb->vgVersion++;

755✔

1238

    code = 0;

755✔

1241

  if (pAlter->compactInterval >= TSDB_DEFAULT_COMPACT_INTERVAL && pAlter->compactInterval != pDb->cfg.compactInterval) {

105,344✔

1242

    pDb->cfg.compactInterval = pAlter->compactInterval;

5,370✔

1243

    pDb->vgVersion++;

5,370✔

1244

    code = 0;

5,370✔

1247

  bool compactTimeRangeChanged = false;

105,344✔

1248

  if (pAlter->compactStartTime != pDb->cfg.compactStartTime &&

105,344✔

1249

      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||

103,005✔

1250

       pAlter->compactStartTime <= -pDb->cfg.daysPerFile)) {

103,005✔

1251

    pDb->cfg.compactStartTime = pAlter->compactStartTime;

4,632✔

1252

    compactTimeRangeChanged = true;

4,632✔

1253

    code = 0;

4,632✔

1256

  if (pAlter->compactEndTime != pDb->cfg.compactEndTime &&

105,344✔

1257

      (pAlter->compactEndTime == TSDB_DEFAULT_COMPACT_END_TIME || pAlter->compactEndTime <= -pDb->cfg.daysPerFile)) {

103,005✔

1258

    pDb->cfg.compactEndTime = pAlter->compactEndTime;

4,632✔

1259

    compactTimeRangeChanged = true;

4,632✔

1260

    code = 0;

4,632✔

1262

  if(compactTimeRangeChanged) {

105,344✔

1263

    pDb->vgVersion++;

4,632✔

1266

  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&

105,344✔

1267

      pAlter->compactTimeOffset != pDb->cfg.compactTimeOffset) {

9,270✔

1268

    pDb->cfg.compactTimeOffset = pAlter->compactTimeOffset;

3,843✔

1269

    pDb->vgVersion++;

3,843✔

1270

    code = 0;

3,843✔

1273

  TAOS_RETURN(code);

105,344✔

1276

static int32_t mndSetAlterDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {

80,271✔

1277

  int32_t  code = 0;

80,271✔

1278

  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);

80,271✔

1279

  if (pRedoRaw == NULL) {

80,271✔

1284

  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {

80,271✔

1289

  if ((code = sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY)) != 0) {

80,271✔

1293

  return 0;

80,271✔

1296

static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {

80,271✔

1297

  int32_t  code = 0;

80,271✔

1298

  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);

80,271✔

1299

  if (pCommitRaw == NULL) {

80,271✔

1304

  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {

80,271✔

1309

  if ((code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)) != 0) {

80,271✔

1313

  TAOS_RETURN(code);

80,271✔

1316

static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {

80,271✔

1317

  int32_t code = 0, lino = 0;

80,271✔

1318

  SSdb   *pSdb = pMnode->pSdb;

80,271✔

1319

  void   *pIter = NULL;

80,271✔

1320

  SVgObj *pVgroup = NULL;

80,271✔

1321

  SArray *pArray = mndBuildDnodesArray(pMnode, 0, NULL);

80,271✔

1323

  TSDB_CHECK_NULL(pArray, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY);

80,271✔

1326

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

542,375✔

1327

    if (pIter == NULL) break;

542,375✔

1329

    if (mndVgroupInDb(pVgroup, pNewDb->uid)) {

462,844✔

1330

      SVgObj newVgroup = {0};

205,069✔

1331

      TAOS_CHECK_GOTO(mndBuildAlterVgroupAction(pMnode, pTrans, pOldDb, pNewDb, pVgroup, pArray, &newVgroup), &lino,

205,069✔

1334

      if (pNewDb->cfg.withArbitrator != pOldDb->cfg.withArbitrator) {

204,329✔

1347

    sdbRelease(pSdb, pVgroup);

462,104✔

1350

  taosArrayDestroy(pArray);

79,531✔

1351

  TAOS_RETURN(code);

79,531✔

1353

_err:

740✔

1354

  mError("db:%s, %s failed at %d since %s", pNewDb->name, __func__, lino, tstrerror(code));

740✔

1356

  sdbCancelFetch(pSdb, pIter);

740✔

1357

  sdbRelease(pSdb, pVgroup);

740✔

1358

  taosArrayDestroy(pArray);

740✔

1359

  TAOS_RETURN(code);

740✔

1362

static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {

80,544✔

1363

  int32_t code = -1;

80,544✔

1364

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "alter-db");

80,544✔

1365

  if (pTrans == NULL) {

80,544✔

1370

  mInfo("trans:%d, used to alter db:%s", pTrans->id, pOld->name);

80,544✔

1371

  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);

80,544✔

1373

  mndTransSetDbName(pTrans, pOld->name, NULL);

80,544✔

1374

  mndTransSetGroupParallel(pTrans);

80,544✔

1375

  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);

80,544✔

1376

  TAOS_CHECK_GOTO(mndTransCheckConflictWithCompact(pMnode, pTrans), NULL, _OVER);

80,544✔

1377

  TAOS_CHECK_GOTO(mndTransCheckConflictWithRetention(pMnode, pTrans), NULL, _OVER);

80,271✔

1379

  TAOS_CHECK_GOTO(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);

80,271✔

1380

  TAOS_CHECK_GOTO(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);

80,271✔

1381

  TAOS_CHECK_GOTO(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew), NULL, _OVER);

80,271✔

1383

  mInfo("trans:%d, used to alter db, ableToBeKilled:%d, killMode:%d", pTrans->id, pTrans->ableToBeKilled, pTrans->killMode);

79,531✔

1384

  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);

79,531✔

1385

  code = 0;

79,531✔

1387

_OVER:

80,544✔

1388

  mndTransDrop(pTrans);

80,544✔

1389

  TAOS_RETURN(code);

80,544✔

1392

static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {

110,505✔

1393

  SMnode     *pMnode = pReq->info.node;

110,505✔

1394

  int32_t     code = -1;

110,505✔

1395

  SDbObj     *pDb = NULL;

110,505✔

1396

  SAlterDbReq alterReq = {0};

110,505✔

1397

  SDbObj      dbObj = {0};

110,505✔

1399

  TAOS_CHECK_GOTO(tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq), NULL, _OVER);

110,505✔

1401

  mInfo("db:%s, start to alter, encryt_algr:%s", alterReq.db, alterReq.encryptAlgrName);

110,505✔

1403

  pDb = mndAcquireDb(pMnode, alterReq.db);

110,505✔

1404

  if (pDb == NULL) {

110,505✔

1405

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

2,464✔

1406

    if (terrno != 0) code = terrno;

2,464✔

1407

    goto _OVER;

2,464✔

1410

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_ALTER_DB, pDb), NULL, _OVER);

108,041✔

1412

  if (alterReq.replications == 2) {

107,689✔

1413

    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), NULL, _OVER);

755✔

1416

  int32_t numOfTopics = 0;

107,689✔

1417

  TAOS_CHECK_GOTO(mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics), NULL, _OVER);

107,689✔

1419

  if (numOfTopics != 0 && alterReq.walRetentionPeriod == 0) {

107,689✔

1426

  if (pDb->cfg.isMount) {

107,689✔

1431

  (void)memcpy(&dbObj, pDb, sizeof(SDbObj));

107,689✔

1432

  if (dbObj.cfg.pRetensions != NULL) {

107,689✔

1437

  if (strlen(alterReq.encryptAlgrName) > 0) {

107,689✔

1438

    mInfo("db:%s, check encryt algr:%s", alterReq.db, alterReq.encryptAlgrName);

3,140✔

1440

    if (strncasecmp(alterReq.encryptAlgrName, "none", TSDB_ENCRYPT_ALGR_NAME_LEN) == 0) {

3,140✔

1441

      if (pDb->cfg.encryptAlgorithm != 0) {

795✔

1447

      SEncryptAlgrObj *pEncryptAlgr = mndAcquireEncryptAlgrByAId(pMnode, alterReq.encryptAlgrName);

2,345✔

1448

      if (pEncryptAlgr != NULL) {

2,345✔

1449

        if (pEncryptAlgr->type != ENCRYPT_ALGR_TYPE__SYMMETRIC_CIPHERS) {

1,550✔

1455

        if (pEncryptAlgr->id != pDb->cfg.encryptAlgorithm) {

1,550✔

1456

          code = TSDB_CODE_MND_ENCRYPT_NOT_ALLOW_CHANGE;

1,550✔

1457

          mError("db:%s, failed to alter, not allowed to change, %s", alterReq.db, alterReq.encryptAlgrName);

1,550✔

1458

          goto _OVER;

1,550✔

1461

        code = TSDB_CODE_MNODE_ENCRYPT_ALGR_NOT_EXIST;

795✔

1462

        mError("db:%s, failed to alter, encrypt algorithm not exist, %s", alterReq.db, alterReq.encryptAlgrName);

795✔

1463

        goto _OVER;

795✔

1468

  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);

105,344✔

1469

  if (code != 0) {

105,344✔

1470

    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;

23,290✔

1471

    goto _OVER;

23,290✔

1474

  TAOS_CHECK_GOTO(mndCheckInChangeDbCfg(pMnode, &pDb->cfg, &dbObj.cfg), NULL, _OVER);

82,054✔

1476

  dbObj.cfgVersion++;

80,544✔

1477

  dbObj.updateTime = taosGetTimestampMs();

80,544✔

1478

  code = mndAlterDb(pMnode, pReq, pDb, &dbObj);

80,544✔

1480

  if (dbObj.cfg.replications != pDb->cfg.replications) {

80,544✔

1482

    mInfo("db:%s, alter db replica from %d to %d", pDb->name, pDb->cfg.replications, dbObj.cfg.replications);

6,856✔

1484

    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

73,688✔

1487

  SName name = {0};

80,544✔

1488

  if (tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

80,544✔

1491

  auditRecord(pReq, pMnode->clusterId, "alterDB", name.dbname, "", alterReq.sql, alterReq.sqlLen);

80,544✔

1493

_OVER:

110,505✔

1494

  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {

110,505✔

1495

    if (terrno != 0) code = terrno;

7,684✔

1496

    mError("db:%s, failed to alter since %s", alterReq.db, tstrerror(code));

7,684✔

1499

  mndReleaseDb(pMnode, pDb);

110,505✔

1500

  taosArrayDestroy(dbObj.cfg.pRetensions);

110,505✔

1501

  tFreeSAlterDbReq(&alterReq);

110,505✔

1503

  TAOS_RETURN(code);

110,505✔

1506

static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb, char *algorithmsId) {

1,457,629✔

1507

  tstrncpy(cfgRsp->db, pDb->name, sizeof(cfgRsp->db));

1,457,629✔

1508

  cfgRsp->dbId = pDb->uid;

1,457,629✔

1509

  cfgRsp->cfgVersion = pDb->cfgVersion;

1,457,629✔

1510

  cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;

1,457,629✔

1511

  cfgRsp->numOfStables = pDb->cfg.numOfStables;

1,457,629✔

1512

  cfgRsp->buffer = pDb->cfg.buffer;

1,457,629✔

1513

  cfgRsp->cacheSize = pDb->cfg.cacheLastSize;

1,457,629✔

1514

  cfgRsp->pageSize = pDb->cfg.pageSize;

1,457,629✔

1515

  cfgRsp->pages = pDb->cfg.pages;

1,457,629✔

1516

  cfgRsp->daysPerFile = pDb->cfg.daysPerFile;

1,457,629✔

1517

  cfgRsp->daysToKeep0 = pDb->cfg.daysToKeep0;

1,457,629✔

1518

  cfgRsp->daysToKeep1 = pDb->cfg.daysToKeep1;

1,457,629✔

1519

  cfgRsp->daysToKeep2 = pDb->cfg.daysToKeep2;

1,457,629✔

1520

  cfgRsp->keepTimeOffset = pDb->cfg.keepTimeOffset;

1,457,629✔

1521

  cfgRsp->minRows = pDb->cfg.minRows;

1,457,629✔

1522

  cfgRsp->maxRows = pDb->cfg.maxRows;

1,457,629✔

1523

  cfgRsp->walFsyncPeriod = pDb->cfg.walFsyncPeriod;

1,457,629✔

1524

  cfgRsp->hashPrefix = pDb->cfg.hashPrefix;

1,457,629✔

1525

  cfgRsp->hashSuffix = pDb->cfg.hashSuffix;

1,457,629✔

1526

  cfgRsp->hashMethod = pDb->cfg.hashMethod;

1,457,629✔

1527

  cfgRsp->walLevel = pDb->cfg.walLevel;

1,457,629✔

1528

  cfgRsp->precision = pDb->cfg.precision;

1,457,629✔

1529

  cfgRsp->compression = pDb->cfg.compression;

1,457,629✔

1530

  cfgRsp->replications = pDb->cfg.replications;

1,457,629✔

1531

  cfgRsp->strict = pDb->cfg.strict;

1,457,629✔

1532

  cfgRsp->cacheLast = pDb->cfg.cacheLast;

1,457,629✔

1533

  cfgRsp->tsdbPageSize = pDb->cfg.tsdbPageSize;

1,457,629✔

1534

  cfgRsp->walRetentionPeriod = pDb->cfg.walRetentionPeriod;

1,457,629✔

1535

  cfgRsp->walRollPeriod = pDb->cfg.walRollPeriod;

1,457,629✔

1536

  cfgRsp->walRetentionSize = pDb->cfg.walRetentionSize;

1,457,629✔

1537

  cfgRsp->walSegmentSize = pDb->cfg.walSegmentSize;

1,457,629✔

1538

  cfgRsp->numOfRetensions = pDb->cfg.numOfRetensions;

1,457,629✔

1539

  cfgRsp->pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);

1,457,629✔

1540

  cfgRsp->schemaless = pDb->cfg.schemaless;

1,457,629✔

1541

  cfgRsp->sstTrigger = pDb->cfg.sstTrigger;

1,457,629✔

1542

  cfgRsp->ssChunkSize = pDb->cfg.ssChunkSize;

1,457,629✔

1543

  cfgRsp->ssKeepLocal = pDb->cfg.ssKeepLocal;

1,457,629✔

1544

  cfgRsp->ssCompact = pDb->cfg.ssCompact;

1,457,629✔

1545

  cfgRsp->withArbitrator = pDb->cfg.withArbitrator;

1,457,629✔

1547

  cfgRsp->compactInterval = pDb->cfg.compactInterval;

1,457,629✔

1548

  cfgRsp->compactStartTime = pDb->cfg.compactStartTime;

1,457,629✔

1549

  cfgRsp->compactEndTime = pDb->cfg.compactEndTime;

1,457,629✔

1550

  cfgRsp->compactTimeOffset = pDb->cfg.compactTimeOffset;

1,457,629✔

1551

  cfgRsp->flags = pDb->cfg.flags;

1,457,629✔

1552

  tstrncpy(cfgRsp->algorithmsId, algorithmsId, sizeof(cfgRsp->algorithmsId));

1,457,629✔

1553

1,457,629✔

1555

static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {

1,603,127✔

1556

  SMnode   *pMnode = pReq->info.node;

1,603,127✔

1557

  int32_t   code = -1;

1,603,127✔

1558

  SDbObj   *pDb = NULL;

1,603,127✔

1559

  SDbCfgReq cfgReq = {0};

1,603,127✔

1560

  SDbCfgRsp cfgRsp = {0};

1,603,127✔

1562

  TAOS_CHECK_GOTO(tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq), NULL, _OVER);

1,603,127✔

1564

  if (strcasecmp(cfgReq.db, TSDB_INFORMATION_SCHEMA_DB) && strcasecmp(cfgReq.db, TSDB_PERFORMANCE_SCHEMA_DB)) {

1,603,127✔

1565

    pDb = mndAcquireDb(pMnode, cfgReq.db);

1,603,127✔

1566

    if (pDb == NULL) {

1,603,127✔

1567

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

286,213✔

1568

      if (terrno != 0) code = terrno;

286,213✔

1569

      goto _OVER;

286,213✔

1572

    char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};

1,316,914✔

1573

    mndGetEncryptOsslAlgrNameById(pMnode, pDb->cfg.encryptAlgorithm, algrId);

1,316,914✔

1574

    mndDumpDbCfgInfo(&cfgRsp, pDb, algrId);

1,316,914✔

1577

  int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);

1,316,914✔

1578

  void   *pRsp = rpcMallocCont(contLen);

1,316,914✔

1579

  if (pRsp == NULL) {

1,316,914✔

1585

  int32_t ret = 0;

1,316,914✔

1586

  if ((ret = tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp)) < 0) {

1,316,914✔

1591

  pReq->info.rsp = pRsp;

1,316,914✔

1592

  pReq->info.rspLen = contLen;

1,316,914✔

1594

  code = 0;

1,316,914✔

1596

_OVER:

1,603,127✔

1598

  tFreeSDbCfgRsp(&cfgRsp);

1,603,127✔

1600

  if (code != 0) {

1,603,127✔

1601

    mError("db:%s, failed to get cfg since %s", cfgReq.db, terrstr());

286,213✔

1604

  mndReleaseDb(pMnode, pDb);

1,603,127✔

1606

  TAOS_RETURN(code);

1,603,127✔

1609

int32_t mndSetDropDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

702,651✔

1610

  int32_t  code = 0;

702,651✔

1611

  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);

702,651✔

1612

  if (pRedoRaw == NULL) {

702,651✔

1617

  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));

702,651✔

1618

  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));

702,651✔

1620

  SSdb *pSdb = pMnode->pSdb;

702,651✔

1621

  void *pIter = NULL;

702,651✔

1623

  while (1) {

4,572✔

1624

    SArbGroup *pArbGroup = NULL;

707,223✔

1625

    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);

707,223✔

1626

    if (pIter == NULL) break;

707,223✔

1628

    if (pArbGroup->dbUid == pDb->uid) {

4,572✔

1629

      if ((code = mndSetDropArbGroupPrepareLogs(pTrans, pArbGroup)) != 0) {

4,572✔

1636

    sdbRelease(pSdb, pArbGroup);

4,572✔

1639

  TAOS_RETURN(code);

702,651✔

1642

int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

702,651✔

1643

  int32_t  code = 0;

702,651✔

1644

  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);

702,651✔

1645

  if (pCommitRaw == NULL) {

702,651✔

1650

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));

702,651✔

1651

  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));

702,651✔

1653

  SSdb *pSdb = pMnode->pSdb;

702,651✔

1654

  void *pIter = NULL;

702,651✔

1656

  while (1) {

4,572✔

1657

    SArbGroup *pArbGroup = NULL;

707,223✔

1658

    pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);

707,223✔

1659

    if (pIter == NULL) break;

707,223✔

1661

    if (pArbGroup->dbUid == pDb->uid) {

4,572✔

1662

      if ((code = mndSetDropArbGroupCommitLogs(pTrans, pArbGroup)) != 0) {

4,572✔

1669

    sdbRelease(pSdb, pArbGroup);

4,572✔

1672

  while (1) {

3,104,213✔

1673

    SVgObj *pVgroup = NULL;

3,806,864✔

1674

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

3,806,864✔

1675

    if (pIter == NULL) break;

3,806,864✔

1677

    if (pVgroup->dbUid == pDb->uid) {

3,104,213✔

1678

      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);

1,429,735✔

1679

      if (pVgRaw == NULL) {

1,429,735✔

1686

      if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {

1,429,735✔

1691

      if ((code = sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED)) != 0) {

1,429,735✔

1698

    sdbRelease(pSdb, pVgroup);

3,104,213✔

1701

  while (1) {

912,186✔

1702

    SStbObj *pStb = NULL;

1,614,837✔

1703

    ESdbStatus status;

1,614,613✔

1704

    pIter = sdbFetchAll(pSdb, SDB_STB, pIter, (void **)&pStb, &status, true);

1,614,837✔

1705

    if (pIter == NULL) break;

1,614,837✔

1707

    if (pStb->dbUid == pDb->uid) {

912,186✔

1708

      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);

528,356✔

1709

      if (pStbRaw == NULL) {

528,356✔

1716

      if ((code = mndTransAppendCommitlog(pTrans, pStbRaw)) != 0) {

528,356✔

1721

      if ((code = sdbSetRawStatus(pStbRaw, SDB_STATUS_DROPPED)) != 0) {

528,356✔

1728

    sdbRelease(pSdb, pStb);

912,186✔

1731

  TAOS_RETURN(code);

702,651✔

1734

static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {

1,429,735✔

1735

  int32_t code = 0;

1,429,735✔

1736

  for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {

2,913,092✔

1737

    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

1,483,357✔

1738

    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, true));

1,483,357✔

1741

  TAOS_RETURN(code);

1,429,735✔

1744

int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {

702,651✔

1745

  int32_t code = 0;

702,651✔

1746

  SSdb   *pSdb = pMnode->pSdb;

702,651✔

1747

  void   *pIter = NULL;

702,651✔

1749

  while (1) {

3,104,213✔

1750

    SVgObj *pVgroup = NULL;

3,806,864✔

1751

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

3,806,864✔

1752

    if (pIter == NULL) break;

3,806,864✔

1754

    if (pVgroup->dbUid == pDb->uid) {

3,104,213✔

1755

      if ((code = mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup)) != 0) {

1,429,735✔

1762

    sdbRelease(pSdb, pVgroup);

3,104,213✔

1765

  TAOS_RETURN(code);

702,651✔

1768

static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {

1,120,238✔

1769

  int32_t    code = 0;

1,120,238✔

1770

  SDropDbRsp dropRsp = {0};

1,120,238✔

1771

  if (pDb != NULL) {

1,120,238✔

1772

    (void)memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);

701,357✔

1773

    dropRsp.uid = pDb->uid;

701,357✔

1776

  int32_t rspLen = tSerializeSDropDbRsp(NULL, 0, &dropRsp);

1,120,238✔

1777

  void   *pRsp = NULL;

1,120,238✔

1778

  if (useRpcMalloc) {

1,120,238✔

1779

    pRsp = rpcMallocCont(rspLen);

418,881✔

1781

    pRsp = taosMemoryMalloc(rspLen);

701,357✔

1784

  if (pRsp == NULL) {

1,120,238✔

1789

  int32_t ret = 0;

1,120,238✔

1790

  if ((ret = tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp)) < 0) return ret;

1,120,238✔

1791

  *pRspLen = rspLen;

1,120,238✔

1792

  *ppRsp = pRsp;

1,120,238✔

1793

  TAOS_RETURN(code);

1,120,238✔

1796

static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {

701,462✔

1797

  int32_t code = -1;

701,462✔

1799

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-db");

701,462✔

1800

  if (pTrans == NULL) {

701,462✔

1806

  mInfo("trans:%d start to drop db:%s", pTrans->id, pDb->name);

701,462✔

1808

  mndTransSetDbName(pTrans, pDb->name, NULL);

701,462✔

1809

  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);

701,462✔

1811

  if (mndTopicExistsForDb(pMnode, pDb)) {

701,462✔

1812

    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;

105✔

1813

    goto _OVER;

105✔

1816

  TAOS_CHECK_GOTO(mndSetDropDbPrepareLogs(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1817

  TAOS_CHECK_GOTO(mndSetDropDbCommitLogs(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1818

  TAOS_CHECK_GOTO(mndDropStreamByDb(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1820

  TAOS_CHECK_GOTO(mndDropViewByDb(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1822

  TAOS_CHECK_GOTO(mndDropTSMAsByDb(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1823

  TAOS_CHECK_GOTO(mndDropRsmasByDb(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1824

  TAOS_CHECK_GOTO(mndDropIdxsByDb(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1826

  TAOS_CHECK_GOTO(mndSetDropDbRedoActions(pMnode, pTrans, pDb), NULL, _OVER);

701,357✔

1827

  TAOS_CHECK_GOTO(mndUserRemoveDb(pMnode, pTrans, pDb, NULL), NULL, _OVER);

701,357✔

1829

  int32_t rspLen = 0;

701,357✔

1830

  void   *pRsp = NULL;

701,357✔

1831

  TAOS_CHECK_GOTO(mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false), NULL, _OVER);

701,357✔

1832

  mndTransSetRpcRsp(pTrans, pRsp, rspLen);

701,357✔

1834

  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);

701,357✔

1835

  code = 0;

701,357✔

1837

_OVER:

701,462✔

1838

  mndTransDrop(pTrans);

701,462✔

1839

  TAOS_RETURN(code);

701,462✔

1842

static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {

1,130,419✔

1843

  SMnode    *pMnode = pReq->info.node;

1,130,419✔

1844

  int32_t    code = -1;

1,130,419✔

1845

  SDbObj    *pDb = NULL;

1,130,419✔

1846

  SDropDbReq dropReq = {0};

1,130,419✔

1848

  TAOS_CHECK_GOTO(tDeserializeSDropDbReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);

1,130,419✔

1850

  mInfo("db:%s, start to drop", dropReq.db);

1,130,419✔

1852

  pDb = mndAcquireDb(pMnode, dropReq.db);

1,130,419✔

1853

  if (pDb == NULL) {

1,130,419✔

1854

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

423,131✔

1855

    if (terrno != 0) code = terrno;

423,131✔

1856

    if (dropReq.ignoreNotExists) {

423,131✔

1857

      code = mndBuildDropDbRsp(pDb, &pReq->info.rspLen, &pReq->info.rsp, true);

418,881✔

1859

    goto _OVER;

423,131✔

1862

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_DB, pDb), NULL, _OVER);

707,288✔

1864

  if(pDb->cfg.isMount) {

705,592✔

1865

    code = TSDB_CODE_MND_MOUNT_OBJ_NOT_SUPPORT;

1,294✔

1866

    goto _OVER;

1,294✔

1869

  SSdb *pSdb = pMnode->pSdb;

704,298✔

1870

  void *pIter = NULL;

704,298✔

1872

  while (1) {

3,122,603✔

1873

    SVgObj *pVgroup = NULL;

3,826,901✔

1874

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

3,826,901✔

1875

    if (pIter == NULL) break;

3,826,901✔

1877

    if (pVgroup->dbUid == pDb->uid) {

3,122,603✔

1878

      bool isFound = false;

1,430,088✔

1879

      for (int32_t i = 0; i < pVgroup->replica; i++) {

2,913,798✔

1880

        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_OFFLINE) {

1,483,710✔

1885

      if (!isFound) {

1,430,088✔

1886

        sdbRelease(pSdb, pVgroup);

1,430,088✔

1887

        continue;

1,430,088✔

1895

    sdbRelease(pSdb, pVgroup);

1,692,515✔

1898

  bool dbStream = false;

704,298✔

1899

  bool vtableStream = false;

704,298✔

1900

  mstCheckDbInUse(pMnode, dropReq.db, &dbStream, &vtableStream, true);

704,298✔

1901

  if (dbStream) {

704,298✔

1902

    code = TSDB_CODE_MND_STREAM_DB_IN_USE;

2,432✔

1903

    mError("db:%s used by streams, drop db not allowed", dropReq.db);

2,432✔

1904

    goto _OVER;

2,432✔

1907

  if (vtableStream && !dropReq.force) {

701,866✔

1908

    code = TSDB_CODE_MND_STREAM_VTABLE_EXITS;

404✔

1909

    mError("db:%s, vtable stream exists, drop db not allowed", dropReq.db);

404✔

1910

    goto _OVER;

404✔

1913

  code = mndDropDb(pMnode, pReq, pDb);

701,462✔

1914

  if (code == TSDB_CODE_SUCCESS) {

701,462✔

1915

    code = TSDB_CODE_ACTION_IN_PROGRESS;

701,357✔

1918

  SName name = {0};

701,462✔

1919

  if (tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB) < 0)

701,462✔

1922

  auditRecord(pReq, pMnode->clusterId, "dropDB", name.dbname, "", dropReq.sql, dropReq.sqlLen);

701,462✔

1924

_OVER:

1,130,419✔

1925

  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_ACTION_IN_PROGRESS) {

1,130,419✔

1926

    mError("db:%s, failed to drop since %s", dropReq.db, terrstr());

10,181✔

1929

  mndReleaseDb(pMnode, pDb);

1,130,419✔

1930

  tFreeSDropDbReq(&dropReq);

1,130,419✔

1931

  TAOS_RETURN(code);

1,130,419✔

1934

static int32_t mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode) {

23,369,219✔

1935

  int32_t numOfTables = 0;

23,369,219✔

1936

  int32_t vindex = 0;

23,369,219✔

1937

  SSdb   *pSdb = pMnode->pSdb;

23,369,219✔

1939

  void *pIter = NULL;

23,369,219✔

1940

  while (vindex < pDb->cfg.numOfVgroups) {

89,721,545✔

1941

    SVgObj *pVgroup = NULL;

66,352,326✔

1942

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

66,352,326✔

1943

    if (pIter == NULL) break;

66,352,326✔

1945

    if (mndVgroupInDb(pVgroup, pDb->uid)) {

66,352,326✔

1946

      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

47,208,098✔

1947

      vindex++;

47,207,400✔

1950

    sdbRelease(pSdb, pVgroup);

66,351,628✔

1953

  sdbCancelFetch(pSdb, pIter);

23,368,456✔

1954

  return numOfTables;

23,369,219✔

1957

void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {

26,107,541✔

1958

  int32_t vindex = 0;

26,107,541✔

1959

  SSdb   *pSdb = pMnode->pSdb;

26,107,541✔

1961

  void *pIter = NULL;

26,108,239✔

1962

  while (1) {

49,173,842✔

1963

    SVgObj *pVgroup = NULL;

75,282,081✔

1964

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

75,282,081✔

1965

    if (pIter == NULL) break;

75,282,081✔

1967

    if ((NULL == pDb || pVgroup->dbUid == pDb->uid) && !pVgroup->isTsma) {

68,912,828✔

1968

      SVgroupInfo vgInfo = {0};

57,251,967✔

1969

      vgInfo.vgId = pVgroup->vgId;

57,251,269✔

1970

      vgInfo.hashBegin = pVgroup->hashBegin;

57,251,269✔

1971

      vgInfo.hashEnd = pVgroup->hashEnd;

57,251,967✔

1972

      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

57,251,967✔

1973

      vgInfo.epSet.numOfEps = pVgroup->replica;

57,251,269✔

1974

      for (int32_t gid = 0; gid < pVgroup->replica; ++gid) {

119,259,191✔

1975

        SVnodeGid *pVgid = &pVgroup->vnodeGid[gid];

62,011,634✔

1976

        SEp       *pEp = &vgInfo.epSet.eps[gid];

62,011,634✔

1977

        SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);

62,011,634✔

1978

        if (pDnode != NULL) {

62,011,917✔

1979

          (void)memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);

61,971,338✔

1980

          pEp->port = pDnode->port;

61,971,338✔

1982

        mndReleaseDnode(pMnode, pDnode);

62,011,917✔

1983

        if (pVgid->syncState == TAOS_SYNC_STATE_LEADER || pVgid->syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {

62,011,623✔

1984

          vgInfo.epSet.inUse = gid;

56,747,967✔

1987

      vindex++;

57,251,967✔

1988

      if (taosArrayPush(pVgList, &vgInfo) == NULL) {

57,251,967✔

1993

    sdbRelease(pSdb, pVgroup);

68,912,828✔

1995

    if (pDb && (vindex >= pDb->cfg.numOfVgroups)) {

68,912,828✔

1996

      sdbCancelFetch(pSdb, pIter);

19,738,986✔

1997

      break;

19,738,986✔

2000

26,108,239✔

2002

int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq) {

20,282,028✔

2003

  int32_t code = 0;

20,282,028✔

2004

  pRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));

20,282,028✔

2005

  if (pRsp->pVgroupInfos == NULL) {

20,282,028✔

2010

  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

20,282,028✔

2012

  if (pReq == NULL || pReq->vgVersion < pDb->vgVersion || pReq->dbId != pDb->uid || numOfTable != pReq->numOfTable ||

20,282,028✔

2013

      pReq->stateTs < pDb->stateTs) {

1,418,531✔

2014

    mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);

18,998,249✔

2017

  (void)memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);

20,282,028✔

2018

  pRsp->uid = pDb->uid;

20,282,028✔

2019

  pRsp->vgVersion = pDb->vgVersion;

20,282,028✔

2020

  pRsp->stateTs = pDb->stateTs;

20,282,028✔

2021

  pRsp->vgNum = taosArrayGetSize(pRsp->pVgroupInfos);

20,282,028✔

2022

  pRsp->hashMethod = pDb->cfg.hashMethod;

20,282,028✔

2023

  pRsp->hashPrefix = pDb->cfg.hashPrefix;

20,282,028✔

2024

  pRsp->hashSuffix = pDb->cfg.hashSuffix;

20,282,028✔

2025

  pRsp->flags = pDb->cfg.flags;

20,282,028✔

2026

  TAOS_RETURN(code);

20,282,028✔

2029

static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {

26,577,610✔

2030

  SMnode   *pMnode = pReq->info.node;

26,577,610✔

2031

  int32_t   code = -1;

26,577,610✔

2032

  SDbObj   *pDb = NULL;

26,577,610✔

2033

  SUseDbReq usedbReq = {0};

26,577,610✔

2034

  SUseDbRsp usedbRsp = {0};

26,577,610✔

2036

  TAOS_CHECK_GOTO(tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq), NULL, _OVER);

26,577,610✔

2038

  char *p = strchr(usedbReq.db, '.');

26,576,912✔

2039

  if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {

26,576,912✔

2040

    (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);

6,149,442✔

2041

    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

6,149,442✔

2042

    if (usedbReq.vgVersion < vgVersion) {

6,148,744✔

2043

      usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));

6,136,484✔

2044

      if (usedbRsp.pVgroupInfos == NULL) goto _OVER;

6,136,484✔

2046

      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);

6,136,484✔

2047

      usedbRsp.vgVersion = vgVersion++;

6,136,484✔

2049

      usedbRsp.vgVersion = usedbReq.vgVersion;

12,260✔

2051

    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);

6,148,744✔

2052

    code = 0;

6,148,744✔

2054

    pDb = mndAcquireDb(pMnode, usedbReq.db);

20,428,168✔

2055

    if (pDb == NULL) {

20,428,667✔

2056

      (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);

129,294✔

2057

      usedbRsp.uid = usedbReq.dbId;

129,294✔

2058

      usedbRsp.vgVersion = usedbReq.vgVersion;

129,294✔

2059

      usedbRsp.errCode = terrno;

129,294✔

2061

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

129,294✔

2062

      if (terrno != 0) code = terrno;

129,294✔

2063

      goto _OVER;

129,294✔

2065

      TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_USE_DB, pDb), NULL, _OVER);

20,299,373✔

2067

      TAOS_CHECK_GOTO(mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq), NULL, _OVER);

20,282,028✔

2069

      mDebug("db:%s, process usedb req vgVersion:%d stateTs:%" PRId64 ", rsp vgVersion:%d stateTs:%" PRId64,

20,282,028✔

2071

      code = 0;

20,282,028✔

2075

  int32_t contLen = tSerializeSUseDbRsp(NULL, 0, &usedbRsp);

26,430,772✔

2076

  void   *pRsp = rpcMallocCont(contLen);

26,430,772✔

2077

  if (pRsp == NULL) {

26,430,772✔

2083

  int32_t ret = 0;

26,430,772✔

2084

  if ((ret = tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp)) < 0) {

26,430,772✔

2089

  pReq->info.rsp = pRsp;

26,430,772✔

2090

  pReq->info.rspLen = contLen;

26,430,772✔

2092

_OVER:

26,577,610✔

2093

  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {

26,577,610✔

2094

    mError("db:%s, failed to process use db req since %s", usedbReq.db, tstrerror(code));

146,838✔

2097

  mndReleaseDb(pMnode, pDb);

26,577,610✔

2098

  tFreeSUsedbRsp(&usedbRsp);

26,577,610✔

2100

  TAOS_RETURN(code);

26,577,610✔

2103

int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {

4,063,558✔

2104

  int32_t       code = 0;

4,063,558✔

2105

  SDbHbBatchRsp batchRsp = {0};

4,063,558✔

2106

  batchRsp.pArray = taosArrayInit(numOfDbs, sizeof(SDbHbRsp));

4,063,558✔

2107

  if (batchRsp.pArray == NULL) {

4,063,558✔

2112

  for (int32_t i = 0; i < numOfDbs; ++i) {

8,851,687✔

2113

    SDbCacheInfo *pDbCacheInfo = &pDbs[i];

4,788,129✔

2114

    pDbCacheInfo->dbId = be64toh(pDbCacheInfo->dbId);

4,788,129✔

2115

    pDbCacheInfo->vgVersion = htonl(pDbCacheInfo->vgVersion);

4,788,129✔

2116

    pDbCacheInfo->cfgVersion = htonl(pDbCacheInfo->cfgVersion);

4,788,129✔

2117

    pDbCacheInfo->numOfTable = htonl(pDbCacheInfo->numOfTable);

4,788,129✔

2118

    pDbCacheInfo->stateTs = be64toh(pDbCacheInfo->stateTs);

4,788,129✔

2119

    pDbCacheInfo->tsmaVersion = htonl(pDbCacheInfo->tsmaVersion);

4,788,129✔

2121

    SDbHbRsp rsp = {0};

4,788,129✔

2122

    (void)memcpy(rsp.db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

4,788,129✔

2123

    rsp.dbId = pDbCacheInfo->dbId;

4,788,129✔

2125

    if ((0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||

4,788,129✔

2126

         (0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {

4,558,050✔

2127

      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

1,676,739✔

2128

      if (pDbCacheInfo->vgVersion >= vgVersion) {

1,676,739✔

2129

        continue;

1,444,322✔

2132

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

232,769✔

2133

      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

232,769✔

2134

      rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));

232,769✔

2136

      mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);

232,769✔

2137

      rsp.useDbRsp->vgVersion = vgVersion++;

232,769✔

2139

      rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);

232,769✔

2141

      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

465,538✔

2146

      continue;

232,769✔

2149

    SDbObj *pDb = mndAcquireDb(pMnode, pDbCacheInfo->dbFName);

3,111,390✔

2150

    if (pDb == NULL) {

3,111,390✔

2151

      mTrace("db:%s, no exist", pDbCacheInfo->dbFName);

24,199✔

2152

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

24,199✔

2153

      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);

24,199✔

2154

      rsp.useDbRsp->uid = pDbCacheInfo->dbId;

24,199✔

2155

      rsp.useDbRsp->vgVersion = -1;

24,199✔

2156

      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

48,398✔

2160

      continue;

24,199✔

2163

    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

3,087,191✔

2165

    if (pDbCacheInfo->vgVersion >= pDb->vgVersion && pDbCacheInfo->cfgVersion >= pDb->cfgVersion &&

3,087,191✔

2166

        numOfTable == pDbCacheInfo->numOfTable && pDbCacheInfo->stateTs == pDb->stateTs &&

2,920,754✔

2167

        pDbCacheInfo->tsmaVersion >= pDb->tsmaVersion) {

2,267,912✔

2168

      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64

2,129,656✔

2172

      mndReleaseDb(pMnode, pDb);

2,129,656✔

2173

      continue;

2,129,656✔

2175

      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64

957,535✔

2181

    if (pDbCacheInfo->cfgVersion < pDb->cfgVersion) {

957,535✔

2182

      rsp.cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp));

140,715✔

2183

      char algrId[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};

140,715✔

2184

      mndGetEncryptOsslAlgrNameById(pMnode, pDb->cfg.encryptAlgorithm, algrId);

140,715✔

2185

      mndDumpDbCfgInfo(rsp.cfgRsp, pDb, algrId);

140,715✔

2188

    if (pDbCacheInfo->tsmaVersion != pDb->tsmaVersion) {

957,535✔

2189

      rsp.pTsmaRsp = taosMemoryCalloc(1, sizeof(STableTSMAInfoRsp));

557,509✔

2190

      if (rsp.pTsmaRsp) rsp.pTsmaRsp->pTsmas = taosArrayInit(4, POINTER_BYTES);

557,509✔

2191

      if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {

557,509✔

2192

        bool    exist = false;

557,509✔

2193

        int32_t code = mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);

557,509✔

2194

        if (TSDB_CODE_SUCCESS != code) {

557,509✔

2205

        rsp.dbTsmaVersion = pDb->tsmaVersion;

557,509✔

2206

        mDebug("update tsma version to %d, got tsma num: %ld", pDb->tsmaVersion, rsp.pTsmaRsp->pTsmas->size);

557,509✔

2210

    if (pDbCacheInfo->vgVersion < pDb->vgVersion || numOfTable != pDbCacheInfo->numOfTable ||

957,535✔

2211

        pDbCacheInfo->stateTs != pDb->stateTs) {

916,451✔

2212

      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));

740,737✔

2213

      rsp.useDbRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));

740,737✔

2214

      if (rsp.useDbRsp->pVgroupInfos == NULL) {

740,737✔

2222

      mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);

740,737✔

2223

      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);

740,737✔

2224

      rsp.useDbRsp->uid = pDb->uid;

740,737✔

2225

      rsp.useDbRsp->vgVersion = pDb->vgVersion;

740,737✔

2226

      rsp.useDbRsp->stateTs = pDb->stateTs;

740,737✔

2227

      rsp.useDbRsp->vgNum = (int32_t)taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);

740,737✔

2228

      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;

740,737✔

2229

      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;

740,737✔

2230

      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;

740,737✔

2231

      rsp.useDbRsp->flags = pDb->cfg.flags;

740,737✔

2234

    if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {

1,915,070✔

2239

    mndReleaseDb(pMnode, pDb);

957,535✔

2242

  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);

4,063,558✔

2243

  void   *pRsp = taosMemoryMalloc(rspLen);

4,063,558✔

2244

  if (pRsp == NULL) {

4,063,558✔

2249

  int32_t ret = 0;

4,063,558✔

2250

  if ((ret = tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp)) < 0) return ret;

4,063,558✔

2252

  *ppRsp = pRsp;

4,063,558✔

2253

  *pRspLen = rspLen;

4,063,558✔

2255

  tFreeSDbHbBatchRsp(&batchRsp);

4,063,558✔

2256

  TAOS_RETURN(code);

4,063,558✔

2259

static int32_t mndSetTrimDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, int64_t startTs, STimeWindow tw,

18,810✔

2262

  int32_t code = 0, lino = 0;

18,810✔

2263

  SSdb   *pSdb = pMnode->pSdb;

18,810✔

2264

  void   *pIter = NULL;

18,810✔

2266

  SRetentionObj obj = {.optrType = type, .triggerType = triggerType};  // reuse SCompactObj struct

18,810✔

2267

  TAOS_CHECK_EXIT(mndAddRetentionToTrans(pMnode, pTrans, &obj, pDb, pRsp));

18,810✔

2269

  int32_t j = 0;

18,810✔

2270

  int32_t numOfVgroups = taosArrayGetSize(vgroupIds);

18,810✔

2271

  if (numOfVgroups > 0) {

18,810✔

2272

    for (int32_t i = 0; i < numOfVgroups; i++) {

9,276✔

2273

      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);

6,957✔

2274

      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);

6,957✔

2276

      if (pVgroup == NULL) {

6,957✔

2277

        mError("db:%s, vgroup:%" PRId64 " not exist", pDb->name, vgId);

2,319✔

2278

        TAOS_CHECK_EXIT(TSDB_CODE_MND_VGROUP_NOT_EXIST);

2,319✔

2279

      } else if (pVgroup->dbUid != pDb->uid) {

4,638✔

2284

      sdbRelease(pSdb, pVgroup);

4,638✔

2287

    for (int32_t i = 0; i < numOfVgroups; i++) {

6,957✔

2288

      int64_t vgId = *(int64_t *)taosArrayGet(vgroupIds, i);

4,638✔

2289

      SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);

4,638✔

2291

      if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {

4,638✔

2296

      for (int32_t i = 0; i < pVgroup->replica; i++) {

9,276✔

2297

        SVnodeGid *gid = &pVgroup->vnodeGid[i];

4,638✔

2298

        if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {

4,638✔

2302

        j++;

4,638✔

2304

      sdbRelease(pSdb, pVgroup);

4,638✔

2307

    while (1) {

58,380✔

2308

      SVgObj *pVgroup = NULL;

72,552✔

2309

      pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

72,552✔

2310

      if (pIter == NULL) break;

72,552✔

2312

      if (pVgroup->dbUid == pDb->uid) {

58,380✔

2313

        if ((code = mndBuildTrimVgroupAction(pMnode, pTrans, pDb, pVgroup, startTs, tw, type, triggerType)) != 0) {

36,814✔

2319

        for (int32_t i = 0; i < pVgroup->replica; i++) {

77,644✔

2320

          SVnodeGid *gid = &pVgroup->vnodeGid[i];

40,830✔

2321

          if ((code = mndAddRetentionDetailToTrans(pMnode, pTrans, &obj, pVgroup, gid, j)) != 0) {

40,830✔

2326

          j++;

40,830✔

2330

      sdbRelease(pSdb, pVgroup);

58,380✔

2333

_exit:

18,810✔

2334

  TAOS_RETURN(code);

18,810✔

2337

static int32_t mndBuildTrimDbRsp(STrimDbRsp *rsp, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {

16,491✔

2338

  int32_t code = 0;

16,491✔

2339

  int32_t rspLen = tSerializeSCompactDbRsp(NULL, 0, (SCompactDbRsp *)rsp);

16,491✔

2340

  void   *pRsp = NULL;

16,491✔

2341

  if (useRpcMalloc) {

16,491✔

2344

    pRsp = taosMemoryMalloc(rspLen);

16,491✔

2347

  if (pRsp == NULL) {

16,491✔

2352

  (void)tSerializeSCompactDbRsp(pRsp, rspLen, (SCompactDbRsp *)rsp);

16,491✔

2353

  *pRspLen = rspLen;

16,491✔

2354

  *ppRsp = pRsp;

16,491✔

2355

  TAOS_RETURN(code);

16,491✔

2358

int32_t mndTrimDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, STimeWindow tw, SArray *vgroupIds,

23,448✔

2360

  SSdb      *pSdb = pMnode->pSdb;

23,448✔

2361

  SVgObj    *pVgroup = NULL;

23,448✔

2362

  void      *pIter = NULL;

23,448✔

2363

  int32_t    code = 0, lino = 0;

23,448✔

2364

  STrimDbRsp rsp = {0};

23,448✔

2365

  bool       isExist = false;

23,448✔

2367

  while (1) {

4,955✔

2368

    SRetentionObj *pObj = NULL;

28,403✔

2369

    pIter = sdbFetch(pMnode->pSdb, SDB_RETENTION, pIter, (void **)&pObj);

28,403✔

2370

    if (pIter == NULL) break;

28,403✔

2372

    if (strcmp(pObj->dbname, pDb->name) == 0) {

4,955✔

2373

      isExist = true;

4,638✔

2375

    sdbRelease(pMnode->pSdb, pObj);

4,955✔

2377

  if (isExist) {

23,448✔

2378

    mInfo("trim db:%s already exist", pDb->name);

4,638✔

2379

    TAOS_RETURN(TSDB_CODE_MND_TRIM_ALREADY_EXIST);

4,638✔

2382

  int64_t startTs = taosGetTimestampMs();

18,810✔

2383

  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "trim-db");

18,810✔

2384

  if (pTrans == NULL) goto _exit;

18,810✔

2385

  mInfo("trans:%d, used to trim db:%s", pTrans->id, pDb->name);

18,810✔

2386

  mndTransSetDbName(pTrans, pDb->name, NULL);

18,810✔

2387

  TAOS_CHECK_EXIT(mndTrancCheckConflict(pMnode, pTrans));

18,810✔

2388

  TAOS_CHECK_EXIT(mndSetTrimDbRedoActions(pMnode, pTrans, pDb, startTs, tw, vgroupIds, type, triggerType, &rsp));

18,810✔

2389

  if (pReq) {

16,491✔

2390

    int32_t rspLen = 0;

16,491✔

2391

    void   *pRsp = NULL;

16,491✔

2392

    rsp.bAccepted = true;

16,491✔

2393

    TAOS_CHECK_EXIT(mndBuildTrimDbRsp(&rsp, &rspLen, &pRsp, false));

16,491✔

2394

    mndTransSetRpcRsp(pTrans, pRsp, rspLen);

16,491✔

2396

  TAOS_CHECK_EXIT(mndTransPrepare(pMnode, pTrans));

16,491✔

2397

_exit:

18,810✔

2398

  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {

18,810✔

2399

    mError("db:%s, failed at line %d to trim db since %s", pDb->name, lino, tstrerror(code));

2,319✔

2401

  mndTransDrop(pTrans);

18,810✔

2402

  TAOS_RETURN(code);

18,810✔

2406

static int32_t mndCheckRsmaInDb(SMnode *pMnode, SDbObj *pDb) {

14,687✔

2407

  int32_t   code = 0;

14,687✔

2408

  void     *pIter = NULL;

14,687✔

2409

  SRsmaObj *pRsma = NULL;

14,687✔

2410

  while ((pIter = sdbFetch(pMnode->pSdb, SDB_RSMA, pIter, (void **)&pRsma))) {

14,687✔

2411

    if (pRsma->dbUid == pDb->uid) {

14,687✔

2412

      sdbRelease(pMnode->pSdb, pRsma);

14,687✔

2413

      sdbCancelFetch(pMnode->pSdb, pIter);

14,687✔

2414

      TAOS_RETURN(code);

14,687✔

2422

static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {

23,448✔

2423

  SMnode    *pMnode = pReq->info.node;

23,448✔

2424

  int32_t    code = 0, lino = 0;

23,448✔

2425

  SDbObj    *pDb = NULL;

23,448✔

2426

  STrimDbReq trimReq = {0};

23,448✔

2428

  TAOS_CHECK_EXIT(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq));

23,448✔

2430

  mInfo("db:%s, start to trim, optr:%u, tw:%" PRId64 ",%" PRId64, trimReq.db, trimReq.optrType, trimReq.tw.skey,

23,448✔

2433

  pDb = mndAcquireDb(pMnode, trimReq.db);

23,448✔

2434

  if (pDb == NULL) {

23,448✔

2440

  TAOS_CHECK_EXIT(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb));

23,448✔

2442

  if (pDb->cfg.isMount) {

23,448✔

2447

  if (trimReq.optrType == TSDB_OPTR_ROLLUP) {

23,448✔

2448

    TAOS_CHECK_EXIT(mndCheckRsmaInDb(pMnode, pDb));

14,687✔

2452

  TAOS_CHECK_EXIT(mndTrimDb(pMnode, pReq, pDb, trimReq.tw, trimReq.vgroupIds, trimReq.optrType, trimReq.triggerType));

23,448✔

2453

  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

16,491✔

2455

  SName name = {0};

16,491✔

2456

  if (tNameFromString(&name, trimReq.db, T_NAME_ACCT | T_NAME_DB) < 0) {

16,491✔

2460

  char optrType[16] = {0};

16,491✔

2461

  (void)snprintf(optrType, sizeof(optrType), "%u", trimReq.optrType);

16,491✔

2463

  auditRecord(pReq, pMnode->clusterId, "trimDB", name.dbname, optrType, trimReq.sql, trimReq.sqlLen);

16,491✔

2465

_exit:

23,448✔

2466

  if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {

23,448✔

2467

    mError("db:%s, failed at line %d to process trim db req since %s, optr:%u", trimReq.db, lino, tstrerror(code),

6,957✔

2471

  mndReleaseDb(pMnode, pDb);

23,448✔

2472

  tFreeSTrimDbReq(&trimReq);

23,448✔

2473

  TAOS_RETURN(code);

23,448✔

2497

static int32_t mndTrimDbWal(SMnode *pMnode, SDbObj *pDb) {

599✔

2498

  SSdb   *pSdb = pMnode->pSdb;

599✔

2499

  SVgObj *pVgroup = NULL;

599✔

2500

  void   *pIter = NULL;

599✔

2501

  int32_t code = 0;

599✔

2504

  while (1) {

1,198✔

2505

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

1,797✔

2506

    if (pIter == NULL) break;

1,797✔

2509

    if (pVgroup->dbUid != pDb->uid) {

1,198✔

2515

    int32_t   contLen = sizeof(SMsgHead);

1,198✔

2516

    SMsgHead *pHead = rpcMallocCont(contLen);

1,198✔

2517

    if (pHead == NULL) {

1,198✔

2523

    pHead->contLen = htonl(contLen);

1,198✔

2524

    pHead->vgId = htonl(pVgroup->vgId);

1,198✔

2527

    SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM_WAL, .pCont = pHead, .contLen = contLen};

1,198✔

2528

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

1,198✔

2529

    code = tmsgSendReq(&epSet, &rpcMsg);

1,198✔

2530

    if (code != 0) {

1,198✔

2533

      mInfo("vgId:%d, send vnode-trim-wal request to vnode", pVgroup->vgId);

1,198✔

2535

    sdbRelease(pSdb, pVgroup);

1,198✔

2538

  return code;

599✔

2541

static int32_t mndProcessTrimDbWalReq(SRpcMsg *pReq) {

599✔

2542

  SMnode    *pMnode = pReq->info.node;

599✔

2543

  int32_t    code = -1;

599✔

2544

  SDbObj    *pDb = NULL;

599✔

2545

  STrimDbReq trimReq = {0};

599✔

2547

  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);

599✔

2549

  mInfo("db:%s, start to trim WAL", trimReq.db);

599✔

2551

  pDb = mndAcquireDb(pMnode, trimReq.db);

599✔

2552

  if (pDb == NULL) {

599✔

2558

  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb), NULL, _OVER);

599✔

2560

  code = mndTrimDbWal(pMnode, pDb);

599✔

2562

_OVER:

599✔

2563

  if (code != 0) {

599✔

2567

  mndReleaseDb(pMnode, pDb);

599✔

2568

  TAOS_RETURN(code);

599✔

2676

const char *mndGetDbStr(const char *src) {

25,117,629✔

2677

  char *pos = strstr(src, TS_PATH_DELIMITER);

25,117,629✔

2678

  if (pos != NULL) ++pos;

25,117,629✔

2679

  if (pos == NULL) return src;

25,117,629✔

2680

  return pos;

23,459,519✔

2683

const char *mndGetStableStr(const char *src) {

21,400,231✔

2684

  char *pos = strstr(src, TS_PATH_DELIMITER);

21,400,231✔

2685

  if (pos != NULL) ++pos;

21,400,231✔

2686

  if (pos == NULL) return src;

21,400,231✔

2687

  return mndGetDbStr(pos);

21,400,231✔

2715

static char *buildRetension(SArray *pRetension) {

742,046✔

2716

  size_t size = taosArrayGetSize(pRetension);

742,046✔

2717

  if (size == 0) {

742,046✔

2718

    return NULL;

742,046✔

2752

static const char *getCacheModelStr(int8_t cacheModel) {

742,046✔

2753

  switch (cacheModel) {

742,046✔

2754

    case TSDB_CACHE_MODEL_NONE:

702,895✔

2755

      return TSDB_CACHE_MODEL_NONE_STR;

702,895✔

2756

    case TSDB_CACHE_MODEL_LAST_ROW:

2,276✔

2757

      return TSDB_CACHE_MODEL_LAST_ROW_STR;

2,276✔

2758

    case TSDB_CACHE_MODEL_LAST_VALUE:

7,229✔

2759

      return TSDB_CACHE_MODEL_LAST_VALUE_STR;

7,229✔

2760

    case TSDB_CACHE_MODEL_BOTH:

29,646✔

2761

      return TSDB_CACHE_MODEL_BOTH_STR;

29,646✔

2768

static void getEncryptAlgorithmStr(SMnode *pMnode, int8_t encryptAlgorithm, char *out) {

742,046✔

2769

  switch (encryptAlgorithm) {

742,046✔

2770

    case TSDB_ENCRYPT_ALGO_NONE: {

742,046✔

2771

      tstrncpy(out, TSDB_ENCRYPT_ALGO_NONE_STR, TSDB_ENCRYPT_ALGR_NAME_LEN);

742,046✔

2772

      break;

742,046✔

2783

742,046✔

2785

bool mndIsDbReady(SMnode *pMnode, SDbObj *pDb) {

2,265,027✔

2786

  if (pDb->cfg.replications == 1) return true;

2,265,027✔

2788

  SSdb *pSdb = pMnode->pSdb;

437,723✔

2789

  void *pIter = NULL;

437,723✔

2790

  bool  isReady = true;

437,723✔

2791

  while (1) {

2,690,064✔

2792

    SVgObj *pVgroup = NULL;

3,127,787✔

2793

    pIter = sdbFetch(pSdb, SDB_VGROUP, pIter, (void **)&pVgroup);

3,127,787✔

2794

    if (pIter == NULL) break;

3,127,787✔

2796

    if (pVgroup->dbUid == pDb->uid && pVgroup->replica > 1) {

2,690,064✔

2797

      bool hasLeader = false;

1,482,722✔

2798

      for (int32_t i = 0; i < pVgroup->replica; ++i) {

5,877,552✔

2799

        if (pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_LEADER ||

4,394,830✔

2800

            pVgroup->vnodeGid[i].syncState == TAOS_SYNC_STATE_ASSIGNED_LEADER) {

3,808,869✔

2801

          hasLeader = true;

585,961✔

2804

      if (!hasLeader) isReady = false;

1,482,722✔

2806

    sdbRelease(pSdb, pVgroup);

2,690,064✔

2809

  return isReady;

437,723✔

2812

static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb, SShowObj *pShow, int32_t rows,

1,973,196✔

2814

  int32_t cols = 0;

1,973,196✔

2815

  int32_t bytes = pShow->pMeta->pSchemas[cols].bytes;

1,973,196✔

2816

  char   *buf = taosMemoryMalloc(bytes);

1,973,196✔

2817

  if (buf == NULL) {

1,973,196✔

2821

  int32_t code = 0;

1,973,196✔

2822

  int32_t lino = 0;

1,973,196✔

2824

  const char *name = mndGetDbStr(pDb->name);

1,973,196✔

2825

  if (name != NULL) {

1,973,196✔

2826

    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);

1,973,196✔

2831

  const char *precStr = NULL;

1,973,196✔

2832

  switch (pDb->cfg.precision) {

1,973,196✔

2833

    case TSDB_TIME_PRECISION_MILLI:

1,916,326✔

2834

      precStr = TSDB_TIME_PRECISION_MILLI_STR;

1,916,326✔

2835

      break;

1,916,326✔

2836

    case TSDB_TIME_PRECISION_MICRO:

18,915✔

2837

      precStr = TSDB_TIME_PRECISION_MICRO_STR;

18,915✔

2838

      break;

18,915✔

2839

    case TSDB_TIME_PRECISION_NANO:

37,955✔

2840

      precStr = TSDB_TIME_PRECISION_NANO_STR;

37,955✔

2841

      break;

37,955✔

2846

  char precVstr[10] = {0};

1,973,196✔

2847

  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);

1,973,196✔

2849

  char *statusStr = "ready";

1,973,196✔

2850

  if (objStatus == SDB_STATUS_CREATING) {

1,973,196✔

2852

  } else if (objStatus == SDB_STATUS_DROPPING) {

1,973,196✔

2855

    if (!sysDb && !mndIsDbReady(pMnode, pDb)) {

1,973,196✔

2856

      statusStr = "unsynced";

1,634✔

2859

  char statusVstr[24] = {0};

1,973,196✔

2860

  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);

1,973,196✔

2862

  if (sysDb || !sysinfo) {

1,973,196✔

2863

    for (int32_t i = 0; i < pShow->numOfColumns; ++i) {

46,783,700✔

2864

      SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);

45,552,550✔

2865

      if (i == 0) {

45,552,550✔

2866

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);

1,231,150✔

2867

      } else if (i == 1) {

44,321,400✔

2868

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);

1,231,150✔

2869

      } else if (i == 3) {

43,090,250✔

2870

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);

1,231,150✔

2871

      } else if (i == 14) {

41,859,100✔

2872

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, precVstr, false), &lino, _OVER);

1,231,150✔

2873

      } else if (i == 15) {

40,627,950✔

2874

        TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, statusVstr, false), &lino, _OVER);

1,231,150✔

2876

        colDataSetNULL(pColInfo, rows);

39,396,800✔

2880

    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2881

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, buf, false), &lino, _OVER);

742,046✔

2883

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2884

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false), &lino, _OVER);

742,046✔

2886

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2887

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false), &lino, _OVER);

742,046✔

2889

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2890

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false), &lino, _OVER);

742,046✔

2892

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2893

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false), &lino, _OVER);

742,046✔

2895

    const char *strictStr = pDb->cfg.strict ? "on" : "off";

742,046✔

2896

    char        strictVstr[24] = {0};

742,046✔

2897

    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);

742,046✔

2898

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2899

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)strictVstr, false), &lino, _OVER);

742,046✔

2901

    char    durationStr[128] = {0};

742,046✔

2902

    char    durationVstr[128] = {0};

742,046✔

2903

    int32_t len = formatDurationOrKeep(&durationVstr[VARSTR_HEADER_SIZE], sizeof(durationVstr) - VARSTR_HEADER_SIZE,

742,046✔

2906

    varDataSetLen(durationVstr, len);

742,046✔

2907

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2908

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

742,046✔

2910

    char keepVstr[128] = {0};

742,046✔

2911

    char keep0Str[32] = {0};

742,046✔

2912

    char keep1Str[32] = {0};

742,046✔

2913

    char keep2Str[32] = {0};

742,046✔

2915

    int32_t lenKeep0 = formatDurationOrKeep(keep0Str, sizeof(keep0Str), pDb->cfg.daysToKeep0);

742,046✔

2916

    int32_t lenKeep1 = formatDurationOrKeep(keep1Str, sizeof(keep1Str), pDb->cfg.daysToKeep1);

742,046✔

2917

    int32_t lenKeep2 = formatDurationOrKeep(keep2Str, sizeof(keep2Str), pDb->cfg.daysToKeep2);

742,046✔

2919

    if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {

742,046✔

2922

      len = tsnprintf(&keepVstr[VARSTR_HEADER_SIZE], sizeof(keepVstr), "%s,%s,%s", keep0Str, keep1Str, keep2Str);

742,046✔

2924

    varDataSetLen(keepVstr, len);

742,046✔

2925

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2926

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keepVstr, false), &lino, _OVER);

742,046✔

2928

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2929

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false), &lino, _OVER);

742,046✔

2931

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2932

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false), &lino, _OVER);

742,046✔

2934

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2935

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false), &lino, _OVER);

742,046✔

2937

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2938

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false), &lino, _OVER);

742,046✔

2940

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2941

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false), &lino, _OVER);

742,046✔

2943

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2944

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false), &lino, _OVER);

742,046✔

2946

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2947

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)precVstr, false), &lino, _OVER);

742,046✔

2949

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2950

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)statusVstr, false), &lino, _OVER);

742,046✔

2952

    char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);

742,046✔

2953

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2954

    if (rentensionVstr == NULL) {

742,046✔

2955

      colDataSetNULL(pColInfo, rows);

742,046✔

2961

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2962

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false), &lino, _OVER);

742,046✔

2964

    const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);

742,046✔

2965

    char        cacheModelVstr[24] = {0};

742,046✔

2966

    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);

742,046✔

2967

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2968

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false), &lino, _OVER);

742,046✔

2970

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2971

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false), &lino, _OVER);

742,046✔

2973

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2974

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false), &lino, _OVER);

742,046✔

2976

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2977

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false), &lino, _OVER);

742,046✔

2979

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2980

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false), &lino, _OVER);

742,046✔

2982

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2983

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false), &lino, _OVER);

742,046✔

2985

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2986

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false), &lino, _OVER);

742,046✔

2988

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2989

    int16_t hashPrefix = pDb->cfg.hashPrefix;

742,046✔

2990

    if (hashPrefix > 0) {

742,046✔

2991

      hashPrefix = pDb->cfg.hashPrefix - strlen(pDb->name) - 1;

4,845✔

2992

    } else if (hashPrefix < 0) {

737,201✔

2993

      hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;

5,440✔

2995

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false), &lino, _OVER);

742,046✔

2997

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

2998

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false), &lino, _OVER);

742,046✔

3000

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3001

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);

742,046✔

3003

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3004

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);

742,046✔

3006

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3007

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssChunkSize, false), &lino, _OVER);

742,046✔

3009

    char keeplocalVstr[128] = {0};

742,046✔

3010

    len = tsnprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr), "%dm", pDb->cfg.ssKeepLocal);

742,046✔

3011

    varDataSetLen(keeplocalVstr, len);

742,046✔

3012

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3013

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);

742,046✔

3015

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3016

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.ssCompact, false), &lino, _OVER);

742,046✔

3018

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3019

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);

742,046✔

3021

    char encryptAlgorithmStr[TSDB_ENCRYPT_ALGR_NAME_LEN] = {0};

742,046✔

3022

    getEncryptAlgorithmStr(pMnode, pDb->cfg.encryptAlgorithm, encryptAlgorithmStr);

742,046✔

3023

    char        encryptAlgorithmVStr[24] = {0};

742,046✔

3024

    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);

742,046✔

3025

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

742,046✔

3026

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);

742,046✔

3028

    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));

742,046✔

3029

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

742,046✔

3030

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

742,046✔

3031

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

742,046✔

3034

    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);

742,046✔

3035

    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));

742,046✔

3036

    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));

742,046✔

3037

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

742,046✔

3038

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

742,046✔

3039

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

742,046✔

3042

    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));

742,046✔

3043

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

742,046✔

3044

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

742,046✔

3045

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

742,046✔

3048

_OVER:

1,973,196✔

3049

  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));

1,973,196✔

3050

  taosMemoryFree(buf);

1,973,196✔

3053

static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

613,463✔

3054

  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));

613,463✔

3055

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

613,463✔

3056

  pDbObj->cfg.numOfVgroups = 0;

613,463✔

3057

  pDbObj->cfg.strict = 1;

613,463✔

3058

  pDbObj->cfg.replications = 1;

613,463✔

3059

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

613,463✔

3060

613,463✔

3062

static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

613,463✔

3063

  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));

613,463✔

3064

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

613,463✔

3065

  pDbObj->cfg.numOfVgroups = 0;

613,463✔

3066

  pDbObj->cfg.strict = 1;

613,463✔

3067

  pDbObj->cfg.replications = 1;

613,463✔

3068

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

613,463✔

3069

613,463✔

3071

static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {

5,676,753✔

3072

  SVgObj  *pVgroup = pObj;

5,676,753✔

3073

  int32_t *numOfTables = p1;

5,676,753✔

3074

  int64_t  uid = *(int64_t *)p2;

5,676,753✔

3075

  if (pVgroup->dbUid == uid) {

5,676,753✔

3076

    *numOfTables += pVgroup->numOfTables;

1,702,363✔

3078

  return true;

5,676,753✔

3081

static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {

613,463✔

3082

  SMnode    *pMnode = pReq->info.node;

613,463✔

3083

  SSdb      *pSdb = pMnode->pSdb;

613,463✔

3084

  int32_t    numOfRows = 0;

613,463✔

3085

  SDbObj    *pDb = NULL;

613,463✔

3086

  SUserObj  *pUser = NULL;

613,463✔

3087

  ESdbStatus objStatus = 0;

613,463✔

3089

  (void)mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);

613,463✔

3090

  if (pUser == NULL) return 0;

613,463✔

3091

  bool sysinfo = pUser->sysInfo;

613,463✔

3094

  if (!pShow->sysDbRsp) {

613,463✔

3095

    SDbObj infoschemaDb = {0};

613,463✔

3096

    setInformationSchemaDbCfg(pMnode, &infoschemaDb);

613,463✔

3097

    size_t numOfTables = 0;

613,463✔

3098

    getVisibleInfosTablesNum(sysinfo, &numOfTables);

613,463✔

3099

    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

613,463✔

3101

    numOfRows += 1;

613,463✔

3103

    SDbObj perfschemaDb = {0};

613,463✔

3104

    setPerfSchemaDbCfg(pMnode, &perfschemaDb);

613,463✔

3105

    numOfTables = 0;

613,463✔

3106

    getPerfDbMeta(NULL, &numOfTables);

613,463✔

3107

    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

613,463✔

3109

    numOfRows += 1;

613,463✔

3110

    pShow->sysDbRsp = true;

613,463✔

3113

  while (numOfRows < rowsCapacity) {

1,371,565✔

3114

    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);

1,371,565✔

3115

    if (pShow->pIter == NULL) break;

1,371,565✔

3117

    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) == 0) {

758,102✔

3118

      int32_t numOfTables = 0;

746,270✔

3119

      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);

746,270✔

3120

      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo);

746,270✔

3121

      numOfRows++;

746,270✔

3124

    sdbRelease(pSdb, pDb);

758,102✔

3127

  pShow->numOfRows += numOfRows;

613,463✔

3128

  mndReleaseUser(pMnode, pUser);

613,463✔

3129

  return numOfRows;

613,463✔

taosdata / TDengine / #4882

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #4882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous