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

63

int32_t mndInitDb(SMnode *pMnode) {

×

64

  SSdbTable table = {

×

75

  mndSetMsgHandle(pMnode, TDMT_MND_CREATE_DB, mndProcessCreateDbReq);

×

76

  mndSetMsgHandle(pMnode, TDMT_MND_ALTER_DB, mndProcessAlterDbReq);

×

77

  mndSetMsgHandle(pMnode, TDMT_MND_DROP_DB, mndProcessDropDbReq);

×

78

  mndSetMsgHandle(pMnode, TDMT_MND_USE_DB, mndProcessUseDbReq);

×

79

  mndSetMsgHandle(pMnode, TDMT_MND_COMPACT_DB, mndProcessCompactDbReq);

×

80

  mndSetMsgHandle(pMnode, TDMT_MND_TRIM_DB, mndProcessTrimDbReq);

×

81

  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_CFG, mndProcessGetDbCfgReq);

×

82

  mndSetMsgHandle(pMnode, TDMT_MND_S3MIGRATE_DB, mndProcessS3MigrateDbReq);

×

83

  mndSetMsgHandle(pMnode, TDMT_MND_GET_DB_INFO, mndProcessUseDbReq);

×

85

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);

×

86

  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);

×

88

  return sdbSetTable(pMnode->pSdb, table);

×

91

void mndCleanupDb(SMnode *pMnode) {}

×

93

SSdbRaw *mndDbActionEncode(SDbObj *pDb) {

×

94

  int32_t code = 0;

×

95

  int32_t lino = 0;

×

96

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

98

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

×

99

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

×

100

  if (pRaw == NULL) goto _OVER;

×

102

  int32_t dataPos = 0;

×

103

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

×

104

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

×

105

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

×

106

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

×

107

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

×

108

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

×

109

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

×

110

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

×

111

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

×

112

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

×

113

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

×

114

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

×

115

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

×

116

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

×

117

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

×

118

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

×

119

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

×

120

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

×

121

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

×

122

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

×

123

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

×

124

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

×

125

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

×

126

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

×

127

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

×

128

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

×

129

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

×

130

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

×

131

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

×

132

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

×

133

    SRetention *pRetension = taosArrayGet(pDb->cfg.pRetensions, i);

×

134

    SDB_SET_INT64(pRaw, dataPos, pRetension->freq, _OVER)

×

135

    SDB_SET_INT64(pRaw, dataPos, pRetension->keep, _OVER)

×

136

    SDB_SET_INT8(pRaw, dataPos, pRetension->freqUnit, _OVER)

×

137

    SDB_SET_INT8(pRaw, dataPos, pRetension->keepUnit, _OVER)

×

139

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

×

140

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

×

141

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

×

142

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

×

143

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

×

144

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

×

145

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

×

146

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

×

147

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

×

148

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

×

149

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

×

150

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

×

151

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

×

152

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

×

153

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

×

154

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

×

155

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

×

156

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

×

157

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

×

158

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

×

159

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

×

161

  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

162

  SDB_SET_DATALEN(pRaw, dataPos, _OVER)

×

164

  terrno = 0;

×

166

_OVER:

×

167

  if (terrno != 0) {

×

168

    mError("db:%s, failed to encode to raw:%p since %s", pDb->name, pRaw, terrstr());

×

169

    sdbFreeRaw(pRaw);

×

170

    return NULL;

×

173

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

×

174

  return pRaw;

×

177

static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {

×

178

  int32_t code = 0;

×

179

  int32_t lino = 0;

×

180

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

181

  SSdbRow *pRow = NULL;

×

182

  SDbObj  *pDb = NULL;

×

184

  int8_t sver = 0;

×

185

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

×

187

  if (sver != DB_VER_NUMBER) {

×

188

    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;

×

189

    goto _OVER;

×

192

  pRow = sdbAllocRow(sizeof(SDbObj));

×

193

  if (pRow == NULL) goto _OVER;

×

195

  pDb = sdbGetRowObj(pRow);

×

196

  if (pDb == NULL) goto _OVER;

×

198

  int32_t dataPos = 0;

×

199

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

×

200

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

×

201

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

×

202

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

×

203

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

×

204

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

×

205

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

×

206

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

×

207

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

×

208

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

×

209

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

×

210

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

×

211

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

×

212

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

×

213

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

×

214

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

×

215

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

×

216

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

×

217

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

×

218

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

×

219

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

×

220

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

×

221

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

×

222

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

×

223

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

×

224

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

×

225

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

×

226

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

×

227

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

×

228

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

×

229

    pDb->cfg.pRetensions = taosArrayInit(pDb->cfg.numOfRetensions, sizeof(SRetention));

×

230

    if (pDb->cfg.pRetensions == NULL) goto _OVER;

×

231

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

×

232

      SRetention retention = {0};

×

233

      SDB_GET_INT64(pRaw, dataPos, &retention.freq, _OVER)

×

234

      SDB_GET_INT64(pRaw, dataPos, &retention.keep, _OVER)

×

235

      SDB_GET_INT8(pRaw, dataPos, &retention.freqUnit, _OVER)

×

236

      SDB_GET_INT8(pRaw, dataPos, &retention.keepUnit, _OVER)

×

237

      if (taosArrayPush(pDb->cfg.pRetensions, &retention) == NULL) {

×

238

        goto _OVER;

×

242

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

×

243

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

×

244

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

×

245

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

×

246

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

×

247

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

×

248

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

×

249

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

×

250

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

×

251

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

×

252

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

×

253

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

×

254

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

×

255

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

×

256

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

×

257

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

×

258

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

×

259

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

×

260

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

×

261

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

×

262

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

×

264

  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

265

  taosInitRWLatch(&pDb->lock);

×

267

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

×

268

    pDb->cfg.s3ChunkSize = TSDB_DEFAULT_S3_CHUNK_SIZE;

×

270

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

×

273

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

×

274

    pDb->cfg.s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL;

×

276

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

×

279

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

×

280

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

×

284

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

×

285

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

×

288

  terrno = 0;

×

290

_OVER:

×

291

  if (terrno != 0) {

×

292

    mError("db:%s, failed to decode from raw:%p since %s", pDb == NULL ? "null" : pDb->name, pRaw, terrstr());

×

293

    taosMemoryFreeClear(pRow);

×

294

    return NULL;

×

297

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

×

298

  return pRow;

×

301

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

×

302

  SSdb    *pSdb = pMnode->pSdb;

×

303

  SSdbRow *pRow = NULL;

×

304

  SDbObj  *pNewDb = NULL;

×

305

  int      code = -1;

×

307

  pRow = mndDbActionDecode(pRaw);

×

308

  if (pRow == NULL) {

×

309

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

310

    if (terrno != 0) code = terrno;

×

311

    goto _OVER;

×

313

  pNewDb = sdbGetRowObj(pRow);

×

314

  if (pNewDb == NULL) {

×

315

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

316

    if (terrno != 0) code = terrno;

×

317

    goto _OVER;

×

320

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

×

321

  if (pOldDb != NULL) {

×

322

    mError("trans:%d, db name already in use. name: %s", pTrans->id, pNewDb->name);

×

323

    sdbRelease(pMnode->pSdb, pOldDb);

×

324

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

325

    if (terrno != 0) code = terrno;

×

326

    goto _OVER;

×

329

  code = 0;

×

330

_OVER:

×

331

  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);

×

332

  taosMemoryFreeClear(pRow);

×

333

  return code;

×

336

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

×

337

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

×

338

  return 0;

×

341

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

×

342

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

×

343

  taosArrayDestroy(pDb->cfg.pRetensions);

×

344

  return 0;

×

347

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

×

348

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

×

349

  taosWLockLatch(&pOld->lock);

×

350

  pOld->updateTime = pNew->updateTime;

×

351

  pOld->cfgVersion = pNew->cfgVersion;

×

352

  pOld->vgVersion = pNew->vgVersion;

×

353

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

×

354

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

×

355

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

×

356

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

×

357

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

×

358

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

×

359

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

×

360

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

×

361

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

×

362

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

×

363

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

×

364

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

×

365

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

×

366

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

×

367

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

×

368

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

×

369

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

×

370

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

×

371

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

×

372

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

×

373

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

×

374

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

×

375

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

×

376

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

×

377

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

×

378

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

×

379

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

×

380

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

×

381

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

×

382

  pOld->compactStartTime = pNew->compactStartTime;

×

383

  pOld->tsmaVersion = pNew->tsmaVersion;

×

384

  taosWUnLockLatch(&pOld->lock);

×

385

  return 0;

×

388

static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {

×

389

  SSdb *pSdb = pMnode->pSdb;

×

390

  return sdbGetTableVer(pSdb, SDB_VGROUP);

×

393

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

×

394

  SSdb   *pSdb = pMnode->pSdb;

×

395

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

×

396

  if (pDb == NULL) {

×

397

    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {

×

398

      terrno = TSDB_CODE_MND_DB_NOT_EXIST;

×

399

    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {

×

400

      terrno = TSDB_CODE_MND_DB_IN_CREATING;

×

401

    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {

×

402

      terrno = TSDB_CODE_MND_DB_IN_DROPPING;

×

404

      terrno = TSDB_CODE_APP_ERROR;

×

405

      mFatal("db:%s, failed to acquire db since %s", db, terrstr());

×

408

  return pDb;

×

411

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

×

412

  SSdb *pSdb = pMnode->pSdb;

×

413

  sdbRelease(pSdb, pDb);

×

414

×

416

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

×

417

  SDbObj *pDb = mndAcquireDb(pMnode, db);

×

418

  if (pDb == NULL) {

×

419

    return false;

×

421

    mndReleaseDb(pMnode, pDb);

×

422

    pDb = NULL;

×

423

    return true;

×

427

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

×

428

  char *pos = strstr(dbName, TS_PATH_DELIMITER);

×

429

  if (pos == NULL) {

×

430

    return TSDB_CODE_MND_INVALID_DB;

×

434

  int32_t code = taosStr2int32(dbName, &acctId);

×

435

  if (code != 0) {

×

436

    return code;

×

439

  if (acctId != pUser->acctId) {

×

440

    return TSDB_CODE_MND_INVALID_DB_ACCT;

×

443

  return 0;

×

446

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

×

447

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

449

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

×

450

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

×

451

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

×

452

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

×

453

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

×

454

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

×

455

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

×

456

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

×

457

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

×

458

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

×

459

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

×

460

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

×

461

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

×

462

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

×

463

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

×

464

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

×

465

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

×

466

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

×

467

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

×

468

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

×

469

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

×

470

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

×

472

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

×

473

  if (pCfg->encryptAlgorithm < TSDB_MIN_ENCRYPT_ALGO || pCfg->encryptAlgorithm > TSDB_MAX_ENCRYPT_ALGO) return code;

×

479

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

×

480

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

×

481

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

×

482

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

×

483

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

×

484

    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

485

    TAOS_RETURN(code);

×

487

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

×

488

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

×

489

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

×

490

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

×

491

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

×

492

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

×

493

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

×

494

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

×

495

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

×

496

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

×

497

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

×

499

  if (pCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;

×

500

  if (pCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;

×

501

  if (pCfg->s3Compact < TSDB_MIN_S3_COMPACT || pCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;

×

503

  if (pCfg->compactInterval != 0 &&

×

504

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

×

505

    return code;

×

506

  if (pCfg->compactStartTime != 0 &&

×

507

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

×

508

    return code;

×

509

  if (pCfg->compactEndTime != 0 &&

×

510

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

×

511

    return code;

×

512

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

×

513

    return code;

×

514

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

×

515

    return code;

×

517

  code = 0;

×

518

  TAOS_RETURN(code);

×

521

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

×

522

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

523

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

×

524

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

×

525

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

×

526

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

×

527

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

×

528

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

×

529

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

×

530

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

×

531

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

×

532

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

×

533

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

×

534

    return code;

×

535

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

×

536

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

×

537

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

×

538

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

×

539

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

×

541

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

×

542

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

×

543

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

×

544

      terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

545

      return code;

×

548

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

×

549

    terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

550

    return code;

×

556

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

×

557

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

558

    return code;

×

560

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

×

561

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

562

    return code;

×

565

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

×

566

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

×

567

    return code;

×

568

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

×

569

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

×

570

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

×

571

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

×

572

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

×

573

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

×

574

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

×

575

    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

576

    return code;

×

578

  if (pNewCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pNewCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;

×

579

  if (pNewCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pNewCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;

×

580

  if (pNewCfg->s3Compact < TSDB_MIN_S3_COMPACT || pNewCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;

×

582

  if (pNewCfg->compactInterval != 0 &&

×

583

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

×

584

    return code;

×

585

  if (pNewCfg->compactStartTime != 0 &&

×

586

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

×

587

    return code;

×

588

  if (pNewCfg->compactEndTime != 0 &&

×

589

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

×

590

    return code;

×

591

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

×

592

      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)

×

593

    return code;

×

594

  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||

×

595

      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

×

596

    return code;

×

598

  code = 0;

×

599

  TAOS_RETURN(code);

×

602

static void mndSetDefaultDbCfg(SDbCfg *pCfg) {

×

603

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

×

604

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

×

605

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

×

606

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

×

607

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

×

608

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

×

609

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

×

610

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

×

611

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

×

612

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

×

613

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

×

614

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

×

615

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

×

616

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

×

617

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

×

618

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

×

619

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

×

620

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

×

621

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

×

622

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

×

623

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

×

624

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

×

625

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

×

626

    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;

×

627

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

×

628

    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;

×

629

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

×

630

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

×

631

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

×

632

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

×

633

  if (pCfg->s3ChunkSize <= 0) pCfg->s3ChunkSize = TSDB_DEFAULT_S3_CHUNK_SIZE;

×

634

  if (pCfg->s3KeepLocal <= 0) pCfg->s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL;

×

635

  if (pCfg->s3Compact < 0) pCfg->s3Compact = TSDB_DEFAULT_S3_COMPACT;

×

636

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

×

637

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

×

638

×

640

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

×

641

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

642

  if (pDbRaw == NULL) return -1;

×

644

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

×

645

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

×

646

  return 0;

×

649

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

×

650

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

×

651

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

×

653

  return 0;

×

656

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

×

657

  int32_t  code = 0;

×

658

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

659

  if (pDbRaw == NULL) {

×

660

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

661

    if (terrno != 0) code = terrno;

×

662

    TAOS_RETURN(code);

×

664

  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));

×

665

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));

×

667

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

×

668

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

669

    if (pVgRaw == NULL) {

×

670

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

671

      if (terrno != 0) code = terrno;

×

672

      TAOS_RETURN(code);

×

674

    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));

×

675

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));

×

678

  if (pDb->cfg.withArbitrator) {

×

679

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

×

680

      SVgObj   *pVgObj = pVgroups + v;

×

681

      SArbGroup arbGroup = {0};

×

682

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

683

      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));

×

687

  TAOS_RETURN(code);

×

690

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

×

691

  int32_t  code = 0;

×

692

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

693

  if (pDbRaw == NULL) {

×

694

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

695

    if (terrno != 0) code = terrno;

×

696

    TAOS_RETURN(code);

×

698

  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));

×

699

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));

×

701

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

×

702

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

703

    if (pVgRaw == NULL) {

×

704

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

705

      if (terrno != 0) code = terrno;

×

706

      TAOS_RETURN(code);

×

708

    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));

×

709

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));

×

712

  if (pDb->cfg.withArbitrator) {

×

713

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

×

714

      SVgObj   *pVgObj = pVgroups + v;

×

715

      SArbGroup arbGroup = {0};

×

716

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

717

      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));

×

721

  TAOS_RETURN(code);

×

724

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

×

726

  int32_t  code = 0;

×

727

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

728

  if (pDbRaw == NULL) {

×

729

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

730

    if (terrno != 0) code = terrno;

×

731

    TAOS_RETURN(code);

×

733

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));

×

734

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));

×

736

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

×

737

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

738

    if (pVgRaw == NULL) {

×

739

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

740

      if (terrno != 0) code = terrno;

×

741

      TAOS_RETURN(code);

×

743

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));

×

744

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));

×

747

  if (pDb->cfg.withArbitrator) {

×

748

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

×

749

      SVgObj   *pVgObj = pVgroups + v;

×

750

      SArbGroup arbGroup = {0};

×

751

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

752

      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));

×

756

  if (pUserDuped) {

×

757

    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);

×

758

    if (pUserRaw == NULL) {

×

759

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

760

      if (terrno != 0) code = terrno;

×

761

      TAOS_RETURN(code);

×

763

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));

×

764

    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));

×

767

  TAOS_RETURN(code);

×

770

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

×

771

  int32_t code = 0;

×

772

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

×

773

    SVgObj *pVgroup = pVgroups + vg;

×

775

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

×

776

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

777

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

×

781

  TAOS_RETURN(code);

×

784

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

×

785

  int32_t code = 0;

×

786

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

×

787

    SVgObj *pVgroup = pVgroups + vg;

×

789

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

×

790

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

791

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

×

795

  TAOS_RETURN(code);

×

798

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

×

799

  int32_t  code = 0;

×

800

  SUserObj newUserObj = {0};

×

801

  SDbObj   dbObj = {0};

×

802

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

×

803

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

×

804

  dbObj.createdTime = taosGetTimestampMs();

×

805

  dbObj.updateTime = dbObj.createdTime;

×

806

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

×

807

  dbObj.cfgVersion = 1;

×

808

  dbObj.vgVersion = 1;

×

809

  dbObj.tsmaVersion = 1;

×

810

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

×

811

  dbObj.cfg = (SDbCfg){

×

812

      .numOfVgroups = pCreate->numOfVgroups,

×

813

      .numOfStables = pCreate->numOfStables,

×

814

      .buffer = pCreate->buffer,

×

815

      .pageSize = pCreate->pageSize,

×

816

      .pages = pCreate->pages,

×

817

      .cacheLastSize = pCreate->cacheLastSize,

×

818

      .daysPerFile = pCreate->daysPerFile,

×

819

      .daysToKeep0 = pCreate->daysToKeep0,

×

820

      .daysToKeep1 = pCreate->daysToKeep1,

×

821

      .daysToKeep2 = pCreate->daysToKeep2,

×

822

      .keepTimeOffset = pCreate->keepTimeOffset,

×

823

      .minRows = pCreate->minRows,

×

824

      .maxRows = pCreate->maxRows,

×

825

      .walFsyncPeriod = pCreate->walFsyncPeriod,

×

826

      .walLevel = pCreate->walLevel,

×

827

      .precision = pCreate->precision,

×

828

      .compression = pCreate->compression,

×

829

      .replications = pCreate->replications,

×

830

      .strict = pCreate->strict,

×

831

      .cacheLast = pCreate->cacheLast,

×

833

      .schemaless = pCreate->schemaless,

×

834

      .walRetentionPeriod = pCreate->walRetentionPeriod,

×

835

      .walRetentionSize = pCreate->walRetentionSize,

×

836

      .walRollPeriod = pCreate->walRollPeriod,

×

837

      .walSegmentSize = pCreate->walSegmentSize,

×

838

      .sstTrigger = pCreate->sstTrigger,

×

839

      .hashPrefix = pCreate->hashPrefix,

×

840

      .hashSuffix = pCreate->hashSuffix,

×

841

      .s3ChunkSize = pCreate->s3ChunkSize,

×

842

      .s3KeepLocal = pCreate->s3KeepLocal,

×

843

      .s3Compact = pCreate->s3Compact,

×

844

      .tsdbPageSize = pCreate->tsdbPageSize,

×

845

      .withArbitrator = pCreate->withArbitrator,

×

846

      .encryptAlgorithm = pCreate->encryptAlgorithm,

×

847

      .compactInterval = pCreate->compactInterval,

×

848

      .compactStartTime = pCreate->compactStartTime,

×

849

      .compactEndTime = pCreate->compactEndTime,

×

850

      .compactTimeOffset = pCreate->compactTimeOffset,

×

853

  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;

×

854

  dbObj.cfg.pRetensions = pCreate->pRetensions;

×

856

  mndSetDefaultDbCfg(&dbObj.cfg);

×

858

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

×

859

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

×

860

    TAOS_RETURN(code);

×

863

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

×

864

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

×

865

    TAOS_RETURN(code);

×

868

  if (dbObj.cfg.hashPrefix > 0) {

×

869

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

×

870

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

×

871

    dbObj.cfg.hashPrefix += dbLen;

×

872

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

×

873

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

×

874

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

×

875

    dbObj.cfg.hashPrefix -= dbLen;

×

878

  SVgObj *pVgroups = NULL;

×

879

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

×

880

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

×

881

    TAOS_RETURN(code);

×

885

  SUserObj *pNewUserDuped = NULL;

×

886

  if (!pUser->superUser) {

×

887

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

×

888

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

×

890

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

×

892

    pNewUserDuped = &newUserObj;

×

895

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

×

896

  if (pTrans == NULL) {

×

897

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

898

    if (terrno != 0) code = terrno;

×

899

    goto _OVER;

×

902

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

×

904

  mndTransSetDbName(pTrans, dbObj.name, NULL);

×

905

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

×

907

  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);

×

908

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

×

909

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

×

910

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

×

911

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

×

912

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

×

913

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

×

914

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

×

916

_OVER:

×

917

  taosMemoryFree(pVgroups);

×

918

  mndUserFreeObj(&newUserObj);

×

919

  mndTransDrop(pTrans);

×

920

  TAOS_RETURN(code);

×

923

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

×

924

  int32_t    code = 0;

×

925

  SSdb      *pSdb = pMnode->pSdb;

×

926

  SDnodeObj *pDnode = NULL;

×

927

  void      *pIter = NULL;

×

930

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

×

931

  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB_ENCRYPTION), NULL, _exit);

×

932

  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {

×

933

    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

934

    mError("db:%s, failed to check encryption key:%" PRIi8 " in mnode leader since it's not loaded", pReq->db,

×

936

    goto _exit;

×

939

  int64_t curMs = taosGetTimestampMs();

×

940

  while ((pIter = sdbFetch(pSdb, SDB_DNODE, pIter, (void **)&pDnode))) {

×

941

    bool online = false;

×

942

    if ((pDnode->encryptionKeyStat != tsEncryptionKeyStat || pDnode->encryptionKeyChksum != tsEncryptionKeyChksum) &&

×

943

        (online = mndIsDnodeOnline(pDnode, curMs))) {

×

944

      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

945

      mError("db:%s, failed to check encryption key:%" PRIi8

×

949

      sdbCancelFetch(pSdb, pIter);

×

950

      sdbRelease(pSdb, pDnode);

×

951

      break;

×

953

    sdbRelease(pSdb, pDnode);

×

961

_exit:

×

962

  TAOS_RETURN(code);

×

976

static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {

×

977

  SMnode      *pMnode = pReq->info.node;

×

978

  int32_t      code = -1;

×

979

  int32_t      lino = 0;

×

980

  SDbObj      *pDb = NULL;

×

981

  SUserObj    *pUser = NULL;

×

982

  SCreateDbReq createReq = {0};

×

983

  SArray      *dnodeList = NULL;

×

985

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

×

986

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

×

988

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

×

995

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

×

997

  pDb = mndAcquireDb(pMnode, createReq.db);

×

998

  if (pDb != NULL) {

×

999

    if (createReq.ignoreExist) {

×

1000

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

×

1001

      code = 0;

×

1002

      goto _OVER;

×

1004

      code = TSDB_CODE_MND_DB_ALREADY_EXIST;

×

1005

      goto _OVER;

×

1008

    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {

×

1009

      code = terrno;

×

1010

      goto _OVER;

×

1011

    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {

×

1012

      goto _OVER;

×

1013

    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {

×

1016

      goto _OVER;

×

1020

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

×

1022

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

×

1024

  if (createReq.replications == 2) {

×

1025

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

×

1028

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

×

1030

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

×

1032

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

×

1034

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

×

1035

  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1037

  SName name = {0};

×

1038

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

×

1039

    mError("db:%s, failed to parse db name", createReq.db);

×

1041

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

×

1043

_OVER:

×

1044

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

×

1045

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

×

1048

  mndReleaseDb(pMnode, pDb);

×

1049

  mndReleaseUser(pMnode, pUser);

×

1050

  tFreeSCreateDbReq(&createReq);

×

1051

  taosArrayDestroy(dnodeList);

×

1053

  TAOS_RETURN(code);

×

1056

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

×

1057

  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;

×

1059

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

×

1060

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

×

1061

    code = 0;

×

1064

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

×

1065

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

×

1066

    code = 0;

×

1069

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

×

1070

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

×

1071

    code = 0;

×

1074

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

×

1075

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

×

1076

    code = 0;

×

1079

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

×

1080

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

×

1081

    code = 0;

×

1084

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

×

1085

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

×

1086

    code = 0;

×

1089

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

×

1090

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

×

1091

    code = 0;

×

1094

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

×

1095

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

×

1096

    code = 0;

×

1099

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

×

1100

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

×

1101

    code = 0;

×

1104

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

×

1105

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

×

1106

    code = 0;

×

1109

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

×

1111

    code = TSDB_CODE_OPS_NOT_SUPPORT;

×

1118

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

×

1119

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

×

1120

    code = 0;

×

1123

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

×

1124

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

×

1125

    code = 0;

×

1128

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

×

1129

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

×

1130

    pDb->vgVersion++;

×

1131

    code = 0;

×

1134

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

×

1135

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

×

1136

    pDb->vgVersion++;

×

1137

    code = 0;

×

1140

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

×

1141

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

×

1142

    pDb->vgVersion++;

×

1143

    code = 0;

×

1146

  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&

×

1147

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

×

1148

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

×

1149

    pDb->vgVersion++;

×

1150

    code = 0;

×

1153

  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&

×

1154

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

×

1155

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

×

1156

    pDb->vgVersion++;

×

1157

    code = 0;

×

1160

  if (pAlter->s3KeepLocal > TSDB_MIN_S3_KEEP_LOCAL && pAlter->s3KeepLocal != pDb->cfg.s3KeepLocal) {

×

1161

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

×

1162

    pDb->vgVersion++;

×

1163

    code = 0;

×

1166

  if (pAlter->s3Compact > TSDB_MIN_S3_COMPACT && pAlter->s3Compact != pDb->cfg.s3Compact) {

×

1167

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

×

1168

    pDb->vgVersion++;

×

1169

    code = 0;

×

1172

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

×

1173

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

×

1174

    pDb->vgVersion++;

×

1175

    code = 0;

×

1178

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

×

1179

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

×

1180

    pDb->vgVersion++;

×

1181

    code = 0;

×

1184

  bool compactTimeRangeChanged = false;

×

1185

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

×

1186

      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||

×

1187

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

×

1188

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

×

1189

    compactTimeRangeChanged = true;

×

1190

    code = 0;

×

1193

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

×

1194

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

×

1195

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

×

1196

    compactTimeRangeChanged = true;

×

1197

    code = 0;

×

1199

  if(compactTimeRangeChanged) {

×

1200

    pDb->vgVersion++;

×

1203

  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&

×

1204

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

×

1205

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

×

1206

    pDb->vgVersion++;

×

1207

    code = 0;

×

1210

  TAOS_RETURN(code);

×

1213

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

×

1214

  int32_t  code = 0;

×

1215

  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);

×

1216

  if (pRedoRaw == NULL) {

×

1217

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1218

    if (terrno != 0) code = terrno;

×

1219

    TAOS_RETURN(code);

×

1221

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

×

1222

    sdbFreeRaw(pRedoRaw);

×

1223

    TAOS_RETURN(code);

×

1226

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

×

1227

    sdbFreeRaw(pRedoRaw);

×

1228

    TAOS_RETURN(code);

×

1230

  return 0;

×

1233

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

×

1234

  int32_t  code = 0;

×

1235

  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);

×

1236

  if (pCommitRaw == NULL) {

×

1237

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1238

    if (terrno != 0) code = terrno;

×

1239

    TAOS_RETURN(code);

×

1241

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

×

1242

    sdbFreeRaw(pCommitRaw);

×

1243

    TAOS_RETURN(code);

×

1246

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

×

1247

    sdbFreeRaw(pCommitRaw);

×

1248

    TAOS_RETURN(code);

×

1250

  TAOS_RETURN(code);

×

1253

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

×

1254

  int32_t code = 0, lino = 0;

×

1255

  SSdb   *pSdb = pMnode->pSdb;

×

1256

  void   *pIter = NULL;

×

1257

  SVgObj *pVgroup = NULL;

×

1258

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

×

1260

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

×

1263

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

×

1264

    if (pIter == NULL) break;

×

1266

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

×

1267

      SVgObj newVgroup = {0};

×

1268

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

×

1271

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

×

1272

        if (pNewDb->cfg.withArbitrator) {

×

1273

          SArbGroup arbGroup = {0};

×

1274

          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(&newVgroup, &arbGroup), &lino, _err);

×

1275

          TAOS_CHECK_GOTO(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);

×

1277

          SArbGroup arbGroup = {0};

×

1278

          TAOS_CHECK_GOTO(mndArbGroupInitFromVgObj(pVgroup, &arbGroup), &lino, _err);

×

1279

          TAOS_CHECK_GOTO(mndSetDropArbGroupCommitLogs(pTrans, &arbGroup), &lino, _err);

×

1284

    sdbRelease(pSdb, pVgroup);

×

1287

  taosArrayDestroy(pArray);

×

1288

  TAOS_RETURN(code);

×

1290

_err:

×

1291

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

×

1293

  sdbCancelFetch(pSdb, pIter);

×

1294

  sdbRelease(pSdb, pVgroup);

×

1295

  taosArrayDestroy(pArray);

×

1296

  TAOS_RETURN(code);

×

1299

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

×

1300

  int32_t code = -1;

×

1301

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

×

1302

  if (pTrans == NULL) {

×

1303

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1304

    if (terrno != 0) code = terrno;

×

1305

    TAOS_RETURN(code);

×

1307

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

×

1308

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

×

1310

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

×

1311

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

×

1312

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

×

1314

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

×

1315

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

×

1316

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

×

1318

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

×

1319

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

×

1320

  code = 0;

×

1322

_OVER:

×

1323

  mndTransDrop(pTrans);

×

1324

  TAOS_RETURN(code);

×

1327

static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {

×

1328

  SMnode     *pMnode = pReq->info.node;

×

1329

  int32_t     code = -1;

×

1330

  SDbObj     *pDb = NULL;

×

1331

  SAlterDbReq alterReq = {0};

×

1332

  SDbObj      dbObj = {0};

×

1334

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

×

1336

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

×

1338

  pDb = mndAcquireDb(pMnode, alterReq.db);

×

1339

  if (pDb == NULL) {

×

1340

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1341

    if (terrno != 0) code = terrno;

×

1342

    goto _OVER;

×

1345

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

×

1347

  if (alterReq.replications == 2) {

×

1348

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

×

1351

  int32_t numOfTopics = 0;

×

1352

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

×

1354

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

×

1355

    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;

×

1356

    mError("db:%s, not allowed to set WAL_RETENTION_PERIOD 0 when there are topics defined. numOfTopics:%d", pDb->name,

×

1358

    goto _OVER;

×

1361

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

×

1362

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

×

1363

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

×

1364

    if (dbObj.cfg.pRetensions == NULL) goto _OVER;

×

1367

  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);

×

1368

  if (code != 0) {

×

1369

    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;

×

1370

    goto _OVER;

×

1373

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

×

1375

  dbObj.cfgVersion++;

×

1376

  dbObj.updateTime = taosGetTimestampMs();

×

1377

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

×

1379

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

×

1381

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

×

1383

    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1386

  SName name = {0};

×

1387

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

×

1388

    mError("db:%s, failed to parse db name", alterReq.db);

×

1390

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

×

1392

_OVER:

×

1393

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

×

1394

    if (terrno != 0) code = terrno;

×

1395

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

×

1398

  mndReleaseDb(pMnode, pDb);

×

1399

  taosArrayDestroy(dbObj.cfg.pRetensions);

×

1400

  tFreeSAlterDbReq(&alterReq);

×

1402

  TAOS_RETURN(code);

×

1405

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

×

1406

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

×

1407

  cfgRsp->dbId = pDb->uid;

×

1408

  cfgRsp->cfgVersion = pDb->cfgVersion;

×

1409

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

×

1410

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

×

1411

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

×

1412

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

×

1413

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

×

1414

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

×

1415

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

×

1416

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

×

1417

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

×

1418

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

×

1419

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

×

1420

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

×

1421

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

×

1422

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

×

1423

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

×

1424

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

×

1425

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

×

1426

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

×

1427

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

×

1428

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

×

1429

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

×

1430

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

×

1431

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

×

1432

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

×

1433

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

×

1434

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

×

1435

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

×

1436

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

×

1437

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

×

1438

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

×

1439

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

×

1440

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

×

1441

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

×

1442

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

×

1443

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

×

1444

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

×

1445

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

×

1446

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

×

1447

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

×

1448

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

×

1449

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

×

1450

×

1452

static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {

×

1453

  SMnode   *pMnode = pReq->info.node;

×

1454

  int32_t   code = -1;

×

1455

  SDbObj   *pDb = NULL;

×

1456

  SDbCfgReq cfgReq = {0};

×

1457

  SDbCfgRsp cfgRsp = {0};

×

1459

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

×

1461

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

×

1462

    pDb = mndAcquireDb(pMnode, cfgReq.db);

×

1463

    if (pDb == NULL) {

×

1464

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1465

      if (terrno != 0) code = terrno;

×

1466

      goto _OVER;

×

1469

    mndDumpDbCfgInfo(&cfgRsp, pDb);

×

1472

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

×

1473

  void   *pRsp = rpcMallocCont(contLen);

×

1474

  if (pRsp == NULL) {

×

1475

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1476

    if (terrno != 0) code = terrno;

×

1477

    goto _OVER;

×

1480

  int32_t ret = 0;

×

1481

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

×

1482

    code = ret;

×

1483

    goto _OVER;

×

1486

  pReq->info.rsp = pRsp;

×

1487

  pReq->info.rspLen = contLen;

×

1489

  code = 0;

×

1491

_OVER:

×

1493

  tFreeSDbCfgRsp(&cfgRsp);

×

1495

  if (code != 0) {

×

1496

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

×

1499

  mndReleaseDb(pMnode, pDb);

×

1501

  TAOS_RETURN(code);

×

1504

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

×

1505

  int32_t  code = 0;

×

1506

  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);

×

1507

  if (pRedoRaw == NULL) {

×

1508

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1509

    if (terrno != 0) code = terrno;

×

1510

    return -1;

×

1512

  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));

×

1513

  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));

×

1515

  SSdb *pSdb = pMnode->pSdb;

×

1516

  void *pIter = NULL;

×

1518

  while (1) {

×

1519

    SArbGroup *pArbGroup = NULL;

×

1520

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

×

1521

    if (pIter == NULL) break;

×

1523

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

×

1524

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

×

1525

        sdbCancelFetch(pSdb, pIter);

×

1526

        sdbRelease(pSdb, pArbGroup);

×

1527

        TAOS_RETURN(code);

×

1531

    sdbRelease(pSdb, pArbGroup);

×

1534

  TAOS_RETURN(code);

×

1537

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

×

1538

  int32_t  code = 0;

×

1539

  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);

×

1540

  if (pCommitRaw == NULL) {

×

1541

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1542

    if (terrno != 0) code = terrno;

×

1543

    return -1;

×

1545

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));

×

1546

  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));

×

1548

  SSdb *pSdb = pMnode->pSdb;

×

1549

  void *pIter = NULL;

×

1551

  while (1) {

×

1552

    SArbGroup *pArbGroup = NULL;

×

1553

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

×

1554

    if (pIter == NULL) break;

×

1556

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

×

1557

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

×

1558

        sdbCancelFetch(pSdb, pIter);

×

1559

        sdbRelease(pSdb, pArbGroup);

×

1560

        TAOS_RETURN(code);

×

1564

    sdbRelease(pSdb, pArbGroup);

×

1567

  while (1) {

×

1568

    SVgObj *pVgroup = NULL;

×

1569

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

×

1570

    if (pIter == NULL) break;

×

1572

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

×

1573

      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);

×

1574

      if (pVgRaw == NULL) {

×

1575

        sdbCancelFetch(pSdb, pIter);

×

1576

        sdbRelease(pSdb, pVgroup);

×

1577

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1578

        if (terrno != 0) code = terrno;

×

1579

        TAOS_RETURN(code);

×

1581

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

×

1582

        sdbCancelFetch(pSdb, pIter);

×

1583

        sdbRelease(pSdb, pVgroup);

×

1584

        TAOS_RETURN(code);

×

1586

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

×

1587

        sdbCancelFetch(pSdb, pIter);

×

1588

        sdbRelease(pSdb, pVgroup);

×

1589

        TAOS_RETURN(code);

×

1593

    sdbRelease(pSdb, pVgroup);

×

1596

  while (1) {

×

1597

    SStbObj *pStb = NULL;

×

1598

    pIter = sdbFetch(pSdb, SDB_STB, pIter, (void **)&pStb);

×

1599

    if (pIter == NULL) break;

×

1601

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

×

1602

      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);

×

1603

      if (pStbRaw == NULL) {

×

1604

        sdbCancelFetch(pSdb, pIter);

×

1605

        sdbRelease(pSdb, pStbRaw);

×

1606

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1607

        if (terrno != 0) code = terrno;

×

1608

        return -1;

×

1610

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

×

1611

        sdbCancelFetch(pSdb, pIter);

×

1612

        sdbRelease(pSdb, pStbRaw);

×

1613

        return -1;

×

1615

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

×

1616

        sdbCancelFetch(pSdb, pIter);

×

1617

        sdbRelease(pSdb, pStbRaw);

×

1618

        return -1;

×

1622

    sdbRelease(pSdb, pStb);

×

1625

  TAOS_RETURN(code);

×

1628

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

×

1629

  int32_t code = 0;

×

1630

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

×

1631

    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

1632

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

×

1635

  TAOS_RETURN(code);

×

1638

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

×

1639

  int32_t code = 0;

×

1640

  SSdb   *pSdb = pMnode->pSdb;

×

1641

  void   *pIter = NULL;

×

1643

  while (1) {

×

1644

    SVgObj *pVgroup = NULL;

×

1645

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

×

1646

    if (pIter == NULL) break;

×

1648

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

×

1649

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

×

1650

        sdbCancelFetch(pSdb, pIter);

×

1651

        sdbRelease(pSdb, pVgroup);

×

1652

        TAOS_RETURN(code);

×

1656

    sdbRelease(pSdb, pVgroup);

×

1659

  TAOS_RETURN(code);

×

1662

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

×

1663

  int32_t    code = 0;

×

1664

  SDropDbRsp dropRsp = {0};

×

1665

  if (pDb != NULL) {

×

1666

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

×

1667

    dropRsp.uid = pDb->uid;

×

1670

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

×

1671

  void   *pRsp = NULL;

×

1672

  if (useRpcMalloc) {

×

1673

    pRsp = rpcMallocCont(rspLen);

×

1675

    pRsp = taosMemoryMalloc(rspLen);

×

1678

  if (pRsp == NULL) {

×

1679

    code = terrno;

×

1680

    TAOS_RETURN(code);

×

1683

  int32_t ret = 0;

×

1684

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

×

1685

  *pRspLen = rspLen;

×

1686

  *ppRsp = pRsp;

×

1687

  TAOS_RETURN(code);

×

1690

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

×

1691

  int32_t code = -1;

×

1693

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

×

1694

  if (pTrans == NULL) {

×

1695

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1696

    if (terrno != 0) code = terrno;

×

1697

    goto _OVER;

×

1700

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

×

1702

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

×

1703

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

×

1705

  if (mndTopicExistsForDb(pMnode, pDb)) {

×

1706

    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;

×

1707

    goto _OVER;

×

1710

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

×

1711

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

×

1712

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

×

1714

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

×

1716

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

×

1717

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

×

1718

  TAOS_CHECK_GOTO(mndStreamSetStopStreamTasksActions(pMnode, pTrans, pDb->uid), NULL, _OVER);

×

1719

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

×

1720

  TAOS_CHECK_GOTO(mndUserRemoveDb(pMnode, pTrans, pDb->name), NULL, _OVER);

×

1722

  int32_t rspLen = 0;

×

1723

  void   *pRsp = NULL;

×

1724

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

×

1725

  mndTransSetRpcRsp(pTrans, pRsp, rspLen);

×

1727

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

×

1728

  code = 0;

×

1730

_OVER:

×

1731

  mndTransDrop(pTrans);

×

1732

  TAOS_RETURN(code);

×

1735

static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {

×

1736

  SMnode    *pMnode = pReq->info.node;

×

1737

  int32_t    code = -1;

×

1738

  SDbObj    *pDb = NULL;

×

1739

  SDropDbReq dropReq = {0};

×

1741

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

×

1743

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

×

1745

  pDb = mndAcquireDb(pMnode, dropReq.db);

×

1746

  if (pDb == NULL) {

×

1747

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1748

    if (terrno != 0) code = terrno;

×

1749

    if (dropReq.ignoreNotExists) {

×

1750

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

×

1752

    goto _OVER;

×

1755

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

×

1757

  code = mndDropDb(pMnode, pReq, pDb);

×

1758

  if (code == TSDB_CODE_SUCCESS) {

×

1759

    code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1762

  SName name = {0};

×

1763

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

×

1764

    mError("db:%s, failed to parse db name", dropReq.db);

×

1766

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

×

1768

_OVER:

×

1769

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

×

1770

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

×

1773

  mndReleaseDb(pMnode, pDb);

×

1774

  tFreeSDropDbReq(&dropReq);

×

1775

  TAOS_RETURN(code);

×

1778

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

×

1779

  int32_t numOfTables = 0;

×

1780

  int32_t vindex = 0;

×

1781

  SSdb   *pSdb = pMnode->pSdb;

×

1783

  void *pIter = NULL;

×

1784

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

×

1785

    SVgObj *pVgroup = NULL;

×

1786

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

×

1787

    if (pIter == NULL) break;

×

1789

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

×

1790

      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

1791

      vindex++;

×

1794

    sdbRelease(pSdb, pVgroup);

×

1797

  sdbCancelFetch(pSdb, pIter);

×

1798

  return numOfTables;

×

1801

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

×

1802

  int32_t vindex = 0;

×

1803

  SSdb   *pSdb = pMnode->pSdb;

×

1805

  void *pIter = NULL;

×

1806

  while (1) {

×

1807

    SVgObj *pVgroup = NULL;

×

1808

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

×

1809

    if (pIter == NULL) break;

×

1811

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

×

1812

      SVgroupInfo vgInfo = {0};

×

1813

      vgInfo.vgId = pVgroup->vgId;

×

1814

      vgInfo.hashBegin = pVgroup->hashBegin;

×

1815

      vgInfo.hashEnd = pVgroup->hashEnd;

×

1816

      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

1817

      vgInfo.epSet.numOfEps = pVgroup->replica;

×

1818

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

×

1819

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

×

1820

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

×

1821

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

×

1822

        if (pDnode != NULL) {

×

1823

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

×

1824

          pEp->port = pDnode->port;

×

1826

        mndReleaseDnode(pMnode, pDnode);

×

1827

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

×

1828

          vgInfo.epSet.inUse = gid;

×

1831

      vindex++;

×

1832

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

×

1833

        mError("db:%s, failed to push vgInfo to array, vgId:%d, but continue next", pDb->name, vgInfo.vgId);

×

1837

    sdbRelease(pSdb, pVgroup);

×

1839

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

×

1840

      sdbCancelFetch(pSdb, pIter);

×

1841

      break;

×

1844

×

1846

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

×

1847

  int32_t code = 0;

×

1848

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

×

1849

  if (pRsp->pVgroupInfos == NULL) {

×

1850

    code = terrno;

×

1851

    TAOS_RETURN(code);

×

1854

  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

1856

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

×

1857

      pReq->stateTs < pDb->stateTs) {

×

1858

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

×

1861

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

×

1862

  pRsp->uid = pDb->uid;

×

1863

  pRsp->vgVersion = pDb->vgVersion;

×

1864

  pRsp->stateTs = pDb->stateTs;

×

1865

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

×

1866

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

×

1867

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

×

1868

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

×

1869

  TAOS_RETURN(code);

×

1872

static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {

×

1873

  SMnode   *pMnode = pReq->info.node;

×

1874

  int32_t   code = -1;

×

1875

  SDbObj   *pDb = NULL;

×

1876

  SUseDbReq usedbReq = {0};

×

1877

  SUseDbRsp usedbRsp = {0};

×

1879

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

×

1881

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

×

1882

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

×

1883

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

×

1884

    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

1885

    if (usedbReq.vgVersion < vgVersion) {

×

1886

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

×

1887

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

×

1889

      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);

×

1890

      usedbRsp.vgVersion = vgVersion++;

×

1892

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

1894

    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);

×

1895

    code = 0;

×

1897

    pDb = mndAcquireDb(pMnode, usedbReq.db);

×

1898

    if (pDb == NULL) {

×

1899

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

×

1900

      usedbRsp.uid = usedbReq.dbId;

×

1901

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

1902

      usedbRsp.errCode = terrno;

×

1904

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1905

      if (terrno != 0) code = terrno;

×

1906

      goto _OVER;

×

1908

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

×

1910

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

×

1912

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

×

1914

      code = 0;

×

1918

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

×

1919

  void   *pRsp = rpcMallocCont(contLen);

×

1920

  if (pRsp == NULL) {

×

1921

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1922

    code = -1;

×

1923

    goto _OVER;

×

1926

  int32_t ret = 0;

×

1927

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

×

1928

    code = ret;

×

1929

    goto _OVER;

×

1932

  pReq->info.rsp = pRsp;

×

1933

  pReq->info.rspLen = contLen;

×

1935

_OVER:

×

1936

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

×

1937

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

×

1940

  mndReleaseDb(pMnode, pDb);

×

1941

  tFreeSUsedbRsp(&usedbRsp);

×

1943

  TAOS_RETURN(code);

×

1946

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

×

1947

  int32_t       code = 0;

×

1948

  SDbHbBatchRsp batchRsp = {0};

×

1949

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

×

1950

  if (batchRsp.pArray == NULL) {

×

1951

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1952

    TAOS_RETURN(code);

×

1955

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

×

1956

    SDbCacheInfo *pDbCacheInfo = &pDbs[i];

×

1957

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

×

1958

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

×

1959

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

×

1960

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

×

1961

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

×

1962

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

×

1964

    SDbHbRsp rsp = {0};

×

1965

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

×

1966

    rsp.dbId = pDbCacheInfo->dbId;

×

1968

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

×

1969

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

×

1970

      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

1971

      if (pDbCacheInfo->vgVersion >= vgVersion) {

×

1972

        continue;

×

1975

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

×

1976

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

×

1977

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

×

1979

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

×

1980

      rsp.useDbRsp->vgVersion = vgVersion++;

×

1982

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

×

1984

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

×

1985

        if (terrno != 0) code = terrno;

×

1986

        return code;

×

1989

      continue;

×

1992

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

×

1993

    if (pDb == NULL) {

×

1994

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

×

1995

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

×

1996

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

×

1997

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

×

1998

      rsp.useDbRsp->vgVersion = -1;

×

1999

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

×

2000

        if (terrno != 0) code = terrno;

×

2001

        return code;

×

2003

      continue;

×

2006

    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

2008

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

×

2009

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

×

2010

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

×

2011

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

×

2015

      mndReleaseDb(pMnode, pDb);

×

2016

      continue;

×

2018

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

×

2024

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

×

2025

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

×

2026

      mndDumpDbCfgInfo(rsp.cfgRsp, pDb);

×

2029

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

×

2030

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

×

2031

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

×

2032

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

×

2033

        bool    exist = false;

×

2034

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

×

2035

        if (TSDB_CODE_SUCCESS != code) {

×

2036

          mndReleaseDb(pMnode, pDb);

×

2037

          if (code != TSDB_CODE_NEED_RETRY) {

×

2038

            mError("db:%s, failed to get db tsmas", pDb->name);

×

2040

            mWarn("db:%s, need retry to get db tsmas", pDb->name);

×

2042

          taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);

×

2043

          taosMemoryFreeClear(rsp.pTsmaRsp);

×

2044

          continue;

×

2046

        rsp.dbTsmaVersion = pDb->tsmaVersion;

×

2047

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

×

2051

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

×

2052

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

×

2053

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

×

2054

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

×

2055

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

×

2056

        mndReleaseDb(pMnode, pDb);

×

2057

        mError("db:%s, failed to malloc usedb response", pDb->name);

×

2058

        taosArrayDestroyP(rsp.pTsmaRsp->pTsmas, tFreeAndClearTableTSMAInfo);

×

2059

        taosMemoryFreeClear(rsp.pTsmaRsp);

×

2060

        continue;

×

2063

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

×

2064

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

×

2065

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

×

2066

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

×

2067

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

×

2068

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

×

2069

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

×

2070

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

×

2071

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

×

2074

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

×

2075

      mndReleaseDb(pMnode, pDb);

×

2076

      if (terrno != 0) code = terrno;

×

2077

      return code;

×

2079

    mndReleaseDb(pMnode, pDb);

×

2082

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

×

2083

  void   *pRsp = taosMemoryMalloc(rspLen);

×

2084

  if (pRsp == NULL) {

×

2085

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

2086

    tFreeSDbHbBatchRsp(&batchRsp);

×

2087

    return -1;

×

2089

  int32_t ret = 0;

×

2090

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

×

2092

  *ppRsp = pRsp;

×

2093

  *pRspLen = rspLen;

×

2095

  tFreeSDbHbBatchRsp(&batchRsp);

×

2096

  TAOS_RETURN(code);

×

2099

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

×

2100

  SSdb       *pSdb = pMnode->pSdb;

×

2101

  SVgObj     *pVgroup = NULL;

×

2102

  void       *pIter = NULL;

×

2103

  int32_t     code = 0;

×

2104

  SVTrimDbReq trimReq = {.timestamp = taosGetTimestampSec()};

×

2105

  int32_t     reqLen = tSerializeSVTrimDbReq(NULL, 0, &trimReq);

×

2106

  int32_t     contLen = reqLen + sizeof(SMsgHead);

×

2108

  while (1) {

×

2109

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

×

2110

    if (pIter == NULL) break;

×

2112

    SMsgHead *pHead = rpcMallocCont(contLen);

×

2113

    if (pHead == NULL) {

×

2114

      sdbCancelFetch(pSdb, pVgroup);

×

2115

      sdbRelease(pSdb, pVgroup);

×

2116

      continue;

×

2118

    pHead->contLen = htonl(contLen);

×

2119

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

×

2120

    int32_t ret = 0;

×

2121

    if ((ret = tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq)) < 0) {

×

2122

      sdbRelease(pSdb, pVgroup);

×

2123

      return ret;

×

2126

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

×

2127

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

2128

    int32_t code = tmsgSendReq(&epSet, &rpcMsg);

×

2129

    if (code != 0) {

×

2130

      mError("vgId:%d, failed to send vnode-trim request to vnode since 0x%x", pVgroup->vgId, code);

×

2132

      mInfo("vgId:%d, send vnode-trim request to vnode, time:%d", pVgroup->vgId, trimReq.timestamp);

×

2134

    sdbRelease(pSdb, pVgroup);

×

2137

  return 0;

×

2140

static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {

×

2141

  SMnode    *pMnode = pReq->info.node;

×

2142

  int32_t    code = -1;

×

2143

  SDbObj    *pDb = NULL;

×

2144

  STrimDbReq trimReq = {0};

×

2146

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

×

2148

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

×

2150

  pDb = mndAcquireDb(pMnode, trimReq.db);

×

2151

  if (pDb == NULL) {

×

2152

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2153

    if (terrno != 0) code = terrno;

×

2154

    goto _OVER;

×

2157

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

×

2159

  code = mndTrimDb(pMnode, pDb);

×

2161

_OVER:

×

2162

  if (code != 0) {

×

2163

    mError("db:%s, failed to process trim db req since %s", trimReq.db, terrstr());

×

2166

  mndReleaseDb(pMnode, pDb);

×

2167

  TAOS_RETURN(code);

×

2170

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

×

2171

  SSdb            *pSdb = pMnode->pSdb;

×

2172

  SVgObj          *pVgroup = NULL;

×

2173

  void            *pIter = NULL;

×

2174

  SVS3MigrateDbReq s3migrateReq = {.timestamp = taosGetTimestampSec()};

×

2175

  int32_t          reqLen = tSerializeSVS3MigrateDbReq(NULL, 0, &s3migrateReq);

×

2176

  int32_t          contLen = reqLen + sizeof(SMsgHead);

×

2177

  int32_t          code = 0;

×

2179

  while (1) {

×

2180

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

×

2181

    if (pIter == NULL) break;

×

2183

    if (pVgroup->dbUid != pDb->uid) continue;

×

2185

    SMsgHead *pHead = rpcMallocCont(contLen);

×

2186

    if (pHead == NULL) {

×

2187

      sdbCancelFetch(pSdb, pVgroup);

×

2188

      sdbRelease(pSdb, pVgroup);

×

2189

      continue;

×

2191

    pHead->contLen = htonl(contLen);

×

2192

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

×

2193

    int32_t ret = 0;

×

2194

    if ((ret = tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq)) < 0) {

×

2195

      sdbRelease(pSdb, pVgroup);

×

2196

      return ret;

×

2199

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

×

2200

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

2201

    int32_t code = tmsgSendReq(&epSet, &rpcMsg);

×

2202

    if (code != 0) {

×

2203

      mError("vgId:%d, failed to send vnode-s3migrate request to vnode since 0x%x", pVgroup->vgId, code);

×

2205

      mInfo("vgId:%d, send vnode-s3migrate request to vnode, time:%d", pVgroup->vgId, s3migrateReq.timestamp);

×

2207

    sdbRelease(pSdb, pVgroup);

×

2210

  return 0;

×

2213

static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq) {

×

2214

  SMnode         *pMnode = pReq->info.node;

×

2215

  int32_t         code = -1;

×

2216

  SDbObj         *pDb = NULL;

×

2217

  SS3MigrateDbReq s3migrateReq = {0};

×

2219

  TAOS_CHECK_GOTO(tDeserializeSS3MigrateDbReq(pReq->pCont, pReq->contLen, &s3migrateReq), NULL, _OVER);

×

2221

  mInfo("db:%s, start to s3migrate", s3migrateReq.db);

×

2223

  pDb = mndAcquireDb(pMnode, s3migrateReq.db);

×

2224

  if (pDb == NULL) {

×

2225

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2226

    if (terrno != 0) code = terrno;

×

2227

    goto _OVER;

×

2230

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

×

2232

  code = mndS3MigrateDb(pMnode, pDb);

×

2234

_OVER:

×

2235

  if (code != 0) {

×

2236

    mError("db:%s, failed to process s3migrate db req since %s", s3migrateReq.db, terrstr());

×

2239

  mndReleaseDb(pMnode, pDb);

×

2240

  TAOS_RETURN(code);

×

2243

const char *mndGetDbStr(const char *src) {

×

2244

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

2245

  if (pos != NULL) ++pos;

×

2246

  if (pos == NULL) return src;

×

2247

  return pos;

×

2250

const char *mndGetStableStr(const char *src) {

×

2251

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

2252

  if (pos != NULL) ++pos;

×

2253

  if (pos == NULL) return src;

×

2254

  return mndGetDbStr(pos);

×

2257

static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {

×

2258

  int64_t v = 0;

×

2259

  switch (unit) {

×

2260

    case 's':

×

2261

      v = val / 1000;

×

2262

      break;

×

2263

    case 'm':

×

2264

      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];

×

2265

      break;

×

2266

    case 'h':

×

2267

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 60);

×

2268

      break;

×

2269

    case 'd':

×

2270

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60);

×

2271

      break;

×

2272

    case 'w':

×

2273

      v = val / (tsTickPerMin[TSDB_TIME_PRECISION_MILLI] * 24 * 60 * 7);

×

2274

      break;

×

2275

    default:

×

2276

      break;

×

2279

  return v;

×

2282

static char *buildRetension(SArray *pRetension) {

×

2283

  size_t size = taosArrayGetSize(pRetension);

×

2284

  if (size == 0) {

×

2285

    return NULL;

×

2288

  char       *p1 = taosMemoryCalloc(1, 100);

×

2289

  SRetention *p = taosArrayGet(pRetension, 0);

×

2291

  int32_t len = 2;

×

2293

  int64_t v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

2294

  int64_t v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

2295

  len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

2297

  if (size > 1) {

×

2298

    len += tsnprintf(p1 + len, 100 - len, ",");

×

2299

    p = taosArrayGet(pRetension, 1);

×

2301

    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

2302

    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

2303

    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

2306

  if (size > 2) {

×

2307

    len += tsnprintf(p1 + len, 100 - len, ",");

×

2308

    p = taosArrayGet(pRetension, 2);

×

2310

    v1 = getValOfDiffPrecision(p->freqUnit, p->freq);

×

2311

    v2 = getValOfDiffPrecision(p->keepUnit, p->keep);

×

2312

    len += tsnprintf(p1 + len, 100 - len, "%" PRId64 "%c:%" PRId64 "%c", v1, p->freqUnit, v2, p->keepUnit);

×

2315

  varDataSetLen(p1, len);

×

2316

  return p1;

×

2319

static const char *getCacheModelStr(int8_t cacheModel) {

×

2320

  switch (cacheModel) {

×

2321

    case TSDB_CACHE_MODEL_NONE:

×

2322

      return TSDB_CACHE_MODEL_NONE_STR;

×

2323

    case TSDB_CACHE_MODEL_LAST_ROW:

×

2324

      return TSDB_CACHE_MODEL_LAST_ROW_STR;

×

2325

    case TSDB_CACHE_MODEL_LAST_VALUE:

×

2326

      return TSDB_CACHE_MODEL_LAST_VALUE_STR;

×

2327

    case TSDB_CACHE_MODEL_BOTH:

×

2328

      return TSDB_CACHE_MODEL_BOTH_STR;

×

2329

    default:

×

2330

      break;

×

2332

  return "unknown";

×

2335

static const char *getEncryptAlgorithmStr(int8_t encryptAlgorithm) {

×

2336

  switch (encryptAlgorithm) {

×

2337

    case TSDB_ENCRYPT_ALGO_NONE:

×

2338

      return TSDB_ENCRYPT_ALGO_NONE_STR;

×

2339

    case TSDB_ENCRYPT_ALGO_SM4:

×

2340

      return TSDB_ENCRYPT_ALGO_SM4_STR;

×

2341

    default:

×

2342

      break;

×

2344

  return "unknown";

×

2347

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

×

2348

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

×

2350

  SSdb *pSdb = pMnode->pSdb;

×

2351

  void *pIter = NULL;

×

2352

  bool  isReady = true;

×

2353

  while (1) {

×

2354

    SVgObj *pVgroup = NULL;

×

2355

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

×

2356

    if (pIter == NULL) break;

×

2358

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

×

2359

      bool hasLeader = false;

×

2360

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

×

2361

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

×

2362

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

×

2363

          hasLeader = true;

×

2366

      if (!hasLeader) isReady = false;

×

2368

    sdbRelease(pSdb, pVgroup);

×

2371

  return isReady;

×

2374

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

×

2376

  int32_t cols = 0;

×

2377

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

×

2378

  char   *buf = taosMemoryMalloc(bytes);

×

2379

  if (buf == NULL) {

×

2380

    mError("db:%s, failed to malloc buffer", pDb->name);

×

2381

    return;

×

2383

  int32_t code = 0;

×

2384

  int32_t lino = 0;

×

2386

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

×

2387

  if (name != NULL) {

×

2388

    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);

×

2390

    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);

×

2393

  const char *precStr = NULL;

×

2394

  switch (pDb->cfg.precision) {

×

2395

    case TSDB_TIME_PRECISION_MILLI:

×

2396

      precStr = TSDB_TIME_PRECISION_MILLI_STR;

×

2397

      break;

×

2398

    case TSDB_TIME_PRECISION_MICRO:

×

2399

      precStr = TSDB_TIME_PRECISION_MICRO_STR;

×

2400

      break;

×

2401

    case TSDB_TIME_PRECISION_NANO:

×

2402

      precStr = TSDB_TIME_PRECISION_NANO_STR;

×

2403

      break;

×

2404

    default:

×

2405

      precStr = "none";

×

2406

      break;

×

2408

  char precVstr[10] = {0};

×

2409

  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);

×

2411

  char *statusStr = "ready";

×

2412

  if (objStatus == SDB_STATUS_CREATING) {

×

2413

    statusStr = "creating";

×

2414

  } else if (objStatus == SDB_STATUS_DROPPING) {

×

2415

    statusStr = "dropping";

×

2417

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

×

2418

      statusStr = "unsynced";

×

2421

  char statusVstr[24] = {0};

×

2422

  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);

×

2424

  if (sysDb || !sysinfo) {

×

2425

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

×

2426

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

×

2427

      if (i == 0) {

×

2428

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

×

2429

      } else if (i == 1) {

×

2430

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

×

2431

      } else if (i == 3) {

×

2432

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

×

2433

      } else if (i == 14) {

×

2434

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

×

2435

      } else if (i == 15) {

×

2436

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

×

2438

        colDataSetNULL(pColInfo, rows);

×

2442

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

×

2443

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

×

2445

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

×

2446

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

×

2448

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

×

2449

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

×

2451

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

×

2452

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

×

2454

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

×

2455

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

×

2457

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

×

2458

    char        strictVstr[24] = {0};

×

2459

    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);

×

2460

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

×

2461

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

×

2463

    char    durationStr[128] = {0};

×

2464

    char    durationVstr[128] = {0};

×

2465

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

×

2468

    varDataSetLen(durationVstr, len);

×

2469

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

×

2470

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

×

2472

    char keepVstr[128] = {0};

×

2473

    char keep0Str[32] = {0};

×

2474

    char keep1Str[32] = {0};

×

2475

    char keep2Str[32] = {0};

×

2477

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

×

2478

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

×

2479

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

×

2481

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

×

2482

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

×

2484

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

×

2486

    varDataSetLen(keepVstr, len);

×

2487

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

×

2488

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

×

2490

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

×

2491

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

×

2493

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

×

2494

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

×

2496

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

×

2497

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

×

2499

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

×

2500

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

×

2502

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

×

2503

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

×

2505

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

×

2506

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

×

2508

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

×

2509

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

×

2511

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

×

2512

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

×

2514

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

×

2515

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

×

2516

    if (rentensionVstr == NULL) {

×

2517

      colDataSetNULL(pColInfo, rows);

×

2519

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

×

2520

      taosMemoryFree(rentensionVstr);

×

2523

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

×

2524

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

×

2526

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

×

2527

    char        cacheModelVstr[24] = {0};

×

2528

    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);

×

2529

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

×

2530

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

×

2532

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

×

2533

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

×

2535

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

×

2536

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

×

2538

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

×

2539

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

×

2541

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

×

2542

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

×

2544

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

×

2545

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

×

2547

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

×

2548

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

×

2550

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

×

2551

    int16_t hashPrefix = pDb->cfg.hashPrefix;

×

2552

    if (hashPrefix > 0) {

×

2553

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

×

2554

    } else if (hashPrefix < 0) {

×

2555

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

×

2557

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

×

2559

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

×

2560

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

×

2562

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

×

2563

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

×

2565

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

×

2566

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

×

2568

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

×

2569

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

×

2571

    char keeplocalVstr[128] = {0};

×

2572

    len = tsnprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr), "%dm", pDb->cfg.s3KeepLocal);

×

2573

    varDataSetLen(keeplocalVstr, len);

×

2574

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

×

2575

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

×

2577

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

×

2578

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

×

2580

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

×

2581

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

×

2583

    const char *encryptAlgorithmStr = getEncryptAlgorithmStr(pDb->cfg.encryptAlgorithm);

×

2584

    char        encryptAlgorithmVStr[24] = {0};

×

2585

    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);

×

2586

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

×

2587

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

×

2589

    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));

×

2590

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2591

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

×

2592

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

×

2595

    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);

×

2596

    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));

×

2597

    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));

×

2598

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2599

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

×

2600

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

×

2603

    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));

×

2604

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2605

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

×

2606

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

×

2609

_OVER:

×

2610

  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));

×

2611

  taosMemoryFree(buf);

×

2614

static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

2615

  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));

×

2616

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

2617

  pDbObj->cfg.numOfVgroups = 0;

×

2618

  pDbObj->cfg.strict = 1;

×

2619

  pDbObj->cfg.replications = 1;

×

2620

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

2621

×

2623

static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

2624

  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));

×

2625

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

2626

  pDbObj->cfg.numOfVgroups = 0;

×

2627

  pDbObj->cfg.strict = 1;

×

2628

  pDbObj->cfg.replications = 1;

×

2629

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

2630

×

2632

static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {

×

2633

  SVgObj  *pVgroup = pObj;

×

2634

  int32_t *numOfTables = p1;

×

2635

  int64_t  uid = *(int64_t *)p2;

×

2636

  if (pVgroup->dbUid == uid) {

×

2637

    *numOfTables += pVgroup->numOfTables;

×

2639

  return true;

×

2642

static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {

×

2643

  SMnode    *pMnode = pReq->info.node;

×

2644

  SSdb      *pSdb = pMnode->pSdb;

×

2645

  int32_t    numOfRows = 0;

×

2646

  SDbObj    *pDb = NULL;

×

2647

  SUserObj  *pUser = NULL;

×

2648

  ESdbStatus objStatus = 0;

×

2650

  (void)mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);

×

2651

  if (pUser == NULL) return 0;

×

2652

  bool sysinfo = pUser->sysInfo;

×

2655

  if (!pShow->sysDbRsp) {

×

2656

    SDbObj infoschemaDb = {0};

×

2657

    setInformationSchemaDbCfg(pMnode, &infoschemaDb);

×

2658

    size_t numOfTables = 0;

×

2659

    getVisibleInfosTablesNum(sysinfo, &numOfTables);

×

2660

    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

2662

    numOfRows += 1;

×

2664

    SDbObj perfschemaDb = {0};

×

2665

    setPerfSchemaDbCfg(pMnode, &perfschemaDb);

×

2666

    numOfTables = 0;

×

2667

    getPerfDbMeta(NULL, &numOfTables);

×

2668

    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

2670

    numOfRows += 1;

×

2671

    pShow->sysDbRsp = true;

×

2674

  while (numOfRows < rowsCapacity) {

×

2675

    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);

×

2676

    if (pShow->pIter == NULL) break;

×

2678

    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) == 0) {

×

2679

      int32_t numOfTables = 0;

×

2680

      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);

×

2681

      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo);

×

2682

      numOfRows++;

×

2685

    sdbRelease(pSdb, pDb);

×

2688

  pShow->numOfRows += numOfRows;

×

2689

  mndReleaseUser(pMnode, pUser);

×

2690

  return numOfRows;

×

2693

static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {

×

2694

  SSdb *pSdb = pMnode->pSdb;

×

2695

  sdbCancelFetchByType(pSdb, pIter, SDB_DB);

×

2696

×

taosdata / TDengine / #3798

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #3798

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