taosdata/TDengine | Build 3599 | 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);

×

84

  mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_DB, mndRetrieveDbs);

×

85

  mndAddShowFreeIterHandle(pMnode, TSDB_MGMT_TABLE_DB, mndCancelGetNextDb);

×

87

  return sdbSetTable(pMnode->pSdb, table);

×

90

void mndCleanupDb(SMnode *pMnode) {}

×

92

SSdbRaw *mndDbActionEncode(SDbObj *pDb) {

×

93

  int32_t code = 0;

×

94

  int32_t lino = 0;

×

95

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

97

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

×

98

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

×

99

  if (pRaw == NULL) goto _OVER;

×

101

  int32_t dataPos = 0;

×

102

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

×

103

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

×

104

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

×

105

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

×

106

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

×

107

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

×

108

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

×

109

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

×

110

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

×

111

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

×

112

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

×

113

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

×

114

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

×

115

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

×

116

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

×

117

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

×

118

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

×

119

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

×

120

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

×

121

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

×

122

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

×

123

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

×

124

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

×

125

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

×

126

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

×

127

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

×

128

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

×

129

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

×

130

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

×

131

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

×

132

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

×

133

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

×

134

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

×

135

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

×

136

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

×

138

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

×

139

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

×

140

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

×

141

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

×

142

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

×

143

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

×

144

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

×

145

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

×

146

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

×

147

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

×

148

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

×

149

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

×

150

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

×

151

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

×

152

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

×

153

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

×

154

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

×

155

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

×

156

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

×

157

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

×

158

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

×

160

  SDB_SET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

161

  SDB_SET_DATALEN(pRaw, dataPos, _OVER)

×

163

  terrno = 0;

×

165

_OVER:

×

166

  if (terrno != 0) {

×

167

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

×

168

    sdbFreeRaw(pRaw);

×

169

    return NULL;

×

172

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

×

173

  return pRaw;

×

176

static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {

×

177

  int32_t code = 0;

×

178

  int32_t lino = 0;

×

179

  terrno = TSDB_CODE_OUT_OF_MEMORY;

×

180

  SSdbRow *pRow = NULL;

×

181

  SDbObj  *pDb = NULL;

×

183

  int8_t sver = 0;

×

184

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

×

186

  if (sver != DB_VER_NUMBER) {

×

187

    terrno = TSDB_CODE_SDB_INVALID_DATA_VER;

×

188

    goto _OVER;

×

191

  pRow = sdbAllocRow(sizeof(SDbObj));

×

192

  if (pRow == NULL) goto _OVER;

×

194

  pDb = sdbGetRowObj(pRow);

×

195

  if (pDb == NULL) goto _OVER;

×

197

  int32_t dataPos = 0;

×

198

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

×

199

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

×

200

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

×

201

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

×

202

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

×

203

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

×

204

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

×

205

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

×

206

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

×

207

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

×

208

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

×

209

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

×

210

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

×

211

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

×

212

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

×

213

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

×

214

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

×

215

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

×

216

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

×

217

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

×

218

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

×

219

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

×

220

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

×

221

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

×

222

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

×

223

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

×

224

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

×

225

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

×

226

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

×

227

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

×

228

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

×

229

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

×

230

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

×

231

      SRetention retention = {0};

×

232

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

×

233

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

×

234

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

×

235

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

×

236

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

×

237

        goto _OVER;

×

241

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

×

242

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

×

243

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

×

244

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

×

245

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

×

246

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

×

247

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

×

248

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

×

249

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

×

250

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

×

251

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

×

252

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

×

253

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

×

254

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

×

255

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

×

256

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

×

257

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

×

258

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

×

259

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

×

260

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

×

261

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

×

263

  SDB_GET_RESERVE(pRaw, dataPos, DB_RESERVE_SIZE, _OVER)

×

264

  taosInitRWLatch(&pDb->lock);

×

266

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

×

267

    pDb->cfg.s3ChunkSize = TSDB_DEFAULT_S3_CHUNK_SIZE;

×

269

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

×

272

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

×

273

    pDb->cfg.s3KeepLocal = TSDB_DEFAULT_S3_KEEP_LOCAL;

×

275

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

×

278

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

×

279

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

×

283

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

×

284

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

×

287

  terrno = 0;

×

289

_OVER:

×

290

  if (terrno != 0) {

×

291

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

×

292

    taosMemoryFreeClear(pRow);

×

293

    return NULL;

×

296

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

×

297

  return pRow;

×

300

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

×

301

  SSdb    *pSdb = pMnode->pSdb;

×

302

  SSdbRow *pRow = NULL;

×

303

  SDbObj  *pNewDb = NULL;

×

304

  int      code = -1;

×

306

  pRow = mndDbActionDecode(pRaw);

×

307

  if (pRow == NULL) {

×

308

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

309

    if (terrno != 0) code = terrno;

×

310

    goto _OVER;

×

312

  pNewDb = sdbGetRowObj(pRow);

×

313

  if (pNewDb == NULL) {

×

314

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

315

    if (terrno != 0) code = terrno;

×

316

    goto _OVER;

×

319

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

×

320

  if (pOldDb != NULL) {

×

321

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

×

322

    sdbRelease(pMnode->pSdb, pOldDb);

×

323

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

324

    if (terrno != 0) code = terrno;

×

325

    goto _OVER;

×

328

  code = 0;

×

329

_OVER:

×

330

  if (pNewDb) mndDbActionDelete(pSdb, pNewDb);

×

331

  taosMemoryFreeClear(pRow);

×

332

  return code;

×

335

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

×

336

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

×

337

  return 0;

×

340

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

×

341

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

×

342

  taosArrayDestroy(pDb->cfg.pRetensions);

×

343

  return 0;

×

346

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

×

347

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

×

348

  taosWLockLatch(&pOld->lock);

×

349

  pOld->updateTime = pNew->updateTime;

×

350

  pOld->cfgVersion = pNew->cfgVersion;

×

351

  pOld->vgVersion = pNew->vgVersion;

×

352

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

×

353

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

×

354

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

×

355

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

×

356

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

×

357

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

×

358

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

×

359

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

×

360

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

×

361

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

×

362

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

×

363

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

×

364

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

×

365

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

×

366

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

×

367

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

×

368

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

×

369

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

×

370

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

×

371

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

×

372

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

×

373

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

×

374

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

×

375

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

×

376

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

×

377

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

×

378

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

×

379

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

×

380

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

×

381

  pOld->compactStartTime = pNew->compactStartTime;

×

382

  pOld->tsmaVersion = pNew->tsmaVersion;

×

383

  taosWUnLockLatch(&pOld->lock);

×

384

  return 0;

×

387

static inline int32_t mndGetGlobalVgroupVersion(SMnode *pMnode) {

×

388

  SSdb *pSdb = pMnode->pSdb;

×

389

  return sdbGetTableVer(pSdb, SDB_VGROUP);

×

392

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

×

393

  SSdb   *pSdb = pMnode->pSdb;

×

394

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

×

395

  if (pDb == NULL) {

×

396

    if (terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {

×

397

      terrno = TSDB_CODE_MND_DB_NOT_EXIST;

×

398

    } else if (terrno == TSDB_CODE_SDB_OBJ_CREATING) {

×

399

      terrno = TSDB_CODE_MND_DB_IN_CREATING;

×

400

    } else if (terrno == TSDB_CODE_SDB_OBJ_DROPPING) {

×

401

      terrno = TSDB_CODE_MND_DB_IN_DROPPING;

×

403

      terrno = TSDB_CODE_APP_ERROR;

×

404

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

×

407

  return pDb;

×

410

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

×

411

  SSdb *pSdb = pMnode->pSdb;

×

412

  sdbRelease(pSdb, pDb);

×

413

×

415

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

×

416

  SDbObj *pDb = mndAcquireDb(pMnode, db);

×

417

  if (pDb == NULL) {

×

418

    return false;

×

420

    mndReleaseDb(pMnode, pDb);

×

421

    pDb = NULL;

×

422

    return true;

×

426

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

×

427

  char *pos = strstr(dbName, TS_PATH_DELIMITER);

×

428

  if (pos == NULL) {

×

429

    return TSDB_CODE_MND_INVALID_DB;

×

433

  int32_t code = taosStr2int32(dbName, &acctId);

×

434

  if (code != 0) {

×

435

    return code;

×

438

  if (acctId != pUser->acctId) {

×

439

    return TSDB_CODE_MND_INVALID_DB_ACCT;

×

442

  return 0;

×

445

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

×

446

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

448

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

×

449

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

×

450

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

×

451

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

×

452

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

×

453

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

×

454

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

×

455

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

×

456

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

×

457

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

×

458

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

×

459

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

×

460

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

×

461

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

×

462

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

×

463

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

×

464

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

×

465

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

×

466

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

×

467

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

×

468

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

×

469

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

×

471

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

×

472

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

×

478

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

×

479

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

×

480

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

×

481

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

×

482

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

×

483

    code = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

484

    TAOS_RETURN(code);

×

486

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

×

487

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

×

488

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

×

489

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

×

490

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

×

491

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

×

492

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

×

493

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

×

494

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

×

495

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

×

496

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

×

498

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

×

499

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

×

500

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

×

502

  if (pCfg->compactInterval != 0 &&

×

503

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

×

504

    return code;

×

505

  if (pCfg->compactStartTime != 0 &&

×

506

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

×

507

    return code;

×

508

  if (pCfg->compactEndTime != 0 &&

×

509

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

×

510

    return code;

×

511

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

×

512

    return code;

×

513

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

×

514

    return code;

×

516

  code = 0;

×

517

  TAOS_RETURN(code);

×

520

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

×

521

  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;

×

522

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

×

523

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

×

524

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

×

525

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

×

526

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

×

527

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

×

528

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

×

529

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

×

530

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

×

531

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

×

532

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

×

533

    return code;

×

534

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

×

535

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

×

536

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

×

537

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

×

538

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

×

540

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

×

541

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

×

542

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

×

543

      terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

544

      return code;

×

547

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

×

548

    terrno = TSDB_CODE_OPS_NOT_SUPPORT;

×

549

    return code;

×

555

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

×

556

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

557

    return code;

×

559

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

×

560

    terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;

×

561

    return code;

×

564

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

×

565

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

×

566

    return code;

×

567

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

×

568

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

×

569

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

×

570

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

×

571

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

×

572

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

×

573

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

×

574

    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;

×

575

    return code;

×

577

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

×

578

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

×

579

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

×

581

  if (pNewCfg->compactInterval != 0 &&

×

582

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

×

583

    return code;

×

584

  if (pNewCfg->compactStartTime != 0 &&

×

585

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

×

586

    return code;

×

587

  if (pNewCfg->compactEndTime != 0 &&

×

588

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

×

589

    return code;

×

590

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

×

591

      pNewCfg->compactStartTime >= pNewCfg->compactEndTime)

×

592

    return code;

×

593

  if (pNewCfg->compactTimeOffset < TSDB_MIN_COMPACT_TIME_OFFSET ||

×

594

      pNewCfg->compactTimeOffset > TSDB_MAX_COMPACT_TIME_OFFSET)

×

595

    return code;

×

597

  code = 0;

×

598

  TAOS_RETURN(code);

×

601

static void mndSetDefaultDbCfg(SDbCfg *pCfg) {

×

602

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

×

603

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

×

604

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

×

605

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

×

606

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

×

607

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

×

608

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

×

609

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

×

610

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

×

611

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

×

612

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

×

613

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

×

614

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

×

615

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

×

616

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

×

617

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

×

618

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

×

619

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

×

620

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

×

621

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

×

622

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

×

623

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

×

624

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

×

625

    pCfg->walRetentionPeriod = TSDB_REPS_DEF_DB_WAL_RET_PERIOD;

×

626

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

×

627

    pCfg->walRetentionSize = TSDB_REPS_DEF_DB_WAL_RET_SIZE;

×

628

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

×

629

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

×

630

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

×

631

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

×

632

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

×

633

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

×

634

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

×

635

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

×

636

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

×

637

×

639

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

×

640

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

641

  if (pDbRaw == NULL) return -1;

×

643

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

×

644

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

×

645

  return 0;

×

648

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

×

649

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

×

650

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

×

652

  return 0;

×

655

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

×

656

  int32_t  code = 0;

×

657

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

658

  if (pDbRaw == NULL) {

×

659

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

660

    if (terrno != 0) code = terrno;

×

661

    TAOS_RETURN(code);

×

663

  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));

×

664

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));

×

666

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

×

667

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

668

    if (pVgRaw == NULL) {

×

669

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

670

      if (terrno != 0) code = terrno;

×

671

      TAOS_RETURN(code);

×

673

    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));

×

674

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));

×

677

  if (pDb->cfg.withArbitrator) {

×

678

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

×

679

      SVgObj   *pVgObj = pVgroups + v;

×

680

      SArbGroup arbGroup = {0};

×

681

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

682

      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));

×

686

  TAOS_RETURN(code);

×

689

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

×

690

  int32_t  code = 0;

×

691

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

692

  if (pDbRaw == NULL) {

×

693

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

694

    if (terrno != 0) code = terrno;

×

695

    TAOS_RETURN(code);

×

697

  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));

×

698

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));

×

700

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

×

701

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

702

    if (pVgRaw == NULL) {

×

703

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

704

      if (terrno != 0) code = terrno;

×

705

      TAOS_RETURN(code);

×

707

    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));

×

708

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));

×

711

  if (pDb->cfg.withArbitrator) {

×

712

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

×

713

      SVgObj   *pVgObj = pVgroups + v;

×

714

      SArbGroup arbGroup = {0};

×

715

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

716

      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));

×

720

  TAOS_RETURN(code);

×

723

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

×

725

  int32_t  code = 0;

×

726

  SSdbRaw *pDbRaw = mndDbActionEncode(pDb);

×

727

  if (pDbRaw == NULL) {

×

728

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

729

    if (terrno != 0) code = terrno;

×

730

    TAOS_RETURN(code);

×

732

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));

×

733

  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));

×

735

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

×

736

    SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);

×

737

    if (pVgRaw == NULL) {

×

738

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

739

      if (terrno != 0) code = terrno;

×

740

      TAOS_RETURN(code);

×

742

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));

×

743

    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));

×

746

  if (pDb->cfg.withArbitrator) {

×

747

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

×

748

      SVgObj   *pVgObj = pVgroups + v;

×

749

      SArbGroup arbGroup = {0};

×

750

      TAOS_CHECK_RETURN(mndArbGroupInitFromVgObj(pVgObj, &arbGroup));

×

751

      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));

×

755

  if (pUserDuped) {

×

756

    SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);

×

757

    if (pUserRaw == NULL) {

×

758

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

759

      if (terrno != 0) code = terrno;

×

760

      TAOS_RETURN(code);

×

762

    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));

×

763

    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));

×

766

  TAOS_RETURN(code);

×

769

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

×

770

  int32_t code = 0;

×

771

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

×

772

    SVgObj *pVgroup = pVgroups + vg;

×

774

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

×

775

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

776

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

×

780

  TAOS_RETURN(code);

×

783

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

×

784

  int32_t code = 0;

×

785

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

×

786

    SVgObj *pVgroup = pVgroups + vg;

×

788

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

×

789

      SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

790

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

×

794

  TAOS_RETURN(code);

×

797

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

×

798

  int32_t  code = 0;

×

799

  SUserObj newUserObj = {0};

×

800

  SDbObj   dbObj = {0};

×

801

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

×

802

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

×

803

  dbObj.createdTime = taosGetTimestampMs();

×

804

  dbObj.updateTime = dbObj.createdTime;

×

805

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

×

806

  dbObj.cfgVersion = 1;

×

807

  dbObj.vgVersion = 1;

×

808

  dbObj.tsmaVersion = 1;

×

809

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

×

810

  dbObj.cfg = (SDbCfg){

×

811

      .numOfVgroups = pCreate->numOfVgroups,

×

812

      .numOfStables = pCreate->numOfStables,

×

813

      .buffer = pCreate->buffer,

×

814

      .pageSize = pCreate->pageSize,

×

815

      .pages = pCreate->pages,

×

816

      .cacheLastSize = pCreate->cacheLastSize,

×

817

      .daysPerFile = pCreate->daysPerFile,

×

818

      .daysToKeep0 = pCreate->daysToKeep0,

×

819

      .daysToKeep1 = pCreate->daysToKeep1,

×

820

      .daysToKeep2 = pCreate->daysToKeep2,

×

821

      .keepTimeOffset = pCreate->keepTimeOffset,

×

822

      .minRows = pCreate->minRows,

×

823

      .maxRows = pCreate->maxRows,

×

824

      .walFsyncPeriod = pCreate->walFsyncPeriod,

×

825

      .walLevel = pCreate->walLevel,

×

826

      .precision = pCreate->precision,

×

827

      .compression = pCreate->compression,

×

828

      .replications = pCreate->replications,

×

829

      .strict = pCreate->strict,

×

830

      .cacheLast = pCreate->cacheLast,

×

832

      .schemaless = pCreate->schemaless,

×

833

      .walRetentionPeriod = pCreate->walRetentionPeriod,

×

834

      .walRetentionSize = pCreate->walRetentionSize,

×

835

      .walRollPeriod = pCreate->walRollPeriod,

×

836

      .walSegmentSize = pCreate->walSegmentSize,

×

837

      .sstTrigger = pCreate->sstTrigger,

×

838

      .hashPrefix = pCreate->hashPrefix,

×

839

      .hashSuffix = pCreate->hashSuffix,

×

840

      .s3ChunkSize = pCreate->s3ChunkSize,

×

841

      .s3KeepLocal = pCreate->s3KeepLocal,

×

842

      .s3Compact = pCreate->s3Compact,

×

843

      .tsdbPageSize = pCreate->tsdbPageSize,

×

844

      .withArbitrator = pCreate->withArbitrator,

×

845

      .encryptAlgorithm = pCreate->encryptAlgorithm,

×

846

      .compactInterval = pCreate->compactInterval,

×

847

      .compactStartTime = pCreate->compactStartTime,

×

848

      .compactEndTime = pCreate->compactEndTime,

×

849

      .compactTimeOffset = pCreate->compactTimeOffset,

×

852

  dbObj.cfg.numOfRetensions = pCreate->numOfRetensions;

×

853

  dbObj.cfg.pRetensions = pCreate->pRetensions;

×

855

  mndSetDefaultDbCfg(&dbObj.cfg);

×

857

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

×

858

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

×

859

    TAOS_RETURN(code);

×

862

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

×

863

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

×

864

    TAOS_RETURN(code);

×

867

  if (dbObj.cfg.hashPrefix > 0) {

×

868

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

×

869

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

×

870

    dbObj.cfg.hashPrefix += dbLen;

×

871

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

×

872

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

×

873

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

×

874

    dbObj.cfg.hashPrefix -= dbLen;

×

877

  SVgObj *pVgroups = NULL;

×

878

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

×

879

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

×

880

    TAOS_RETURN(code);

×

884

  SUserObj *pNewUserDuped = NULL;

×

885

  if (!pUser->superUser) {

×

886

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

×

887

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

×

889

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

×

891

    pNewUserDuped = &newUserObj;

×

894

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

×

895

  if (pTrans == NULL) {

×

896

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

897

    if (terrno != 0) code = terrno;

×

898

    goto _OVER;

×

901

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

×

903

  mndTransSetDbName(pTrans, dbObj.name, NULL);

×

904

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

×

906

  mndTransSetOper(pTrans, MND_OPER_CREATE_DB);

×

907

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

×

908

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

×

909

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

×

910

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

×

911

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

×

912

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

×

913

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

×

915

_OVER:

×

916

  taosMemoryFree(pVgroups);

×

917

  mndUserFreeObj(&newUserObj);

×

918

  mndTransDrop(pTrans);

×

919

  TAOS_RETURN(code);

×

922

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

×

923

  int32_t    code = 0;

×

924

  SSdb      *pSdb = pMnode->pSdb;

×

925

  SDnodeObj *pDnode = NULL;

×

926

  void      *pIter = NULL;

×

929

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

×

930

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

×

931

  if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {

×

932

    code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

933

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

×

935

    goto _exit;

×

938

  int64_t curMs = taosGetTimestampMs();

×

939

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

×

940

    bool online = false;

×

941

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

×

942

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

×

943

      code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;

×

944

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

×

948

      sdbCancelFetch(pSdb, pIter);

×

949

      sdbRelease(pSdb, pDnode);

×

950

      break;

×

952

    sdbRelease(pSdb, pDnode);

×

960

_exit:

×

961

  TAOS_RETURN(code);

×

975

static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {

×

976

  SMnode      *pMnode = pReq->info.node;

×

977

  int32_t      code = -1;

×

978

  int32_t      lino = 0;

×

979

  SDbObj      *pDb = NULL;

×

980

  SUserObj    *pUser = NULL;

×

981

  SCreateDbReq createReq = {0};

×

982

  SArray      *dnodeList = NULL;

×

984

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

×

985

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

×

987

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

×

994

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

×

996

  pDb = mndAcquireDb(pMnode, createReq.db);

×

997

  if (pDb != NULL) {

×

998

    if (createReq.ignoreExist) {

×

999

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

×

1000

      code = 0;

×

1001

      goto _OVER;

×

1003

      code = TSDB_CODE_MND_DB_ALREADY_EXIST;

×

1004

      goto _OVER;

×

1007

    if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {

×

1008

      code = terrno;

×

1009

      goto _OVER;

×

1010

    } else if (terrno == TSDB_CODE_MND_DB_IN_DROPPING) {

×

1011

      goto _OVER;

×

1012

    } else if (terrno == TSDB_CODE_MND_DB_NOT_EXIST) {

×

1015

      goto _OVER;

×

1019

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

×

1021

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

×

1023

  if (createReq.replications == 2) {

×

1024

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

×

1027

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

×

1029

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

×

1031

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

×

1033

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

×

1034

  if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1036

  SName name = {0};

×

1037

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

×

1038

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

×

1040

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

×

1042

_OVER:

×

1043

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

×

1044

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

×

1047

  mndReleaseDb(pMnode, pDb);

×

1048

  mndReleaseUser(pMnode, pUser);

×

1049

  tFreeSCreateDbReq(&createReq);

×

1050

  taosArrayDestroy(dnodeList);

×

1052

  TAOS_RETURN(code);

×

1055

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

×

1056

  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;

×

1058

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

×

1059

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

×

1060

    code = 0;

×

1063

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

×

1064

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

×

1065

    code = 0;

×

1068

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

×

1069

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

×

1070

    code = 0;

×

1073

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

×

1074

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

×

1075

    code = 0;

×

1078

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

×

1079

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

×

1080

    code = 0;

×

1083

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

×

1084

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

×

1085

    code = 0;

×

1088

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

×

1089

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

×

1090

    code = 0;

×

1093

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

×

1094

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

×

1095

    code = 0;

×

1098

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

×

1099

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

×

1100

    code = 0;

×

1103

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

×

1104

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

×

1105

    code = 0;

×

1108

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

×

1110

    code = TSDB_CODE_OPS_NOT_SUPPORT;

×

1117

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

×

1118

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

×

1119

    code = 0;

×

1122

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

×

1123

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

×

1124

    code = 0;

×

1127

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

×

1128

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

×

1129

    pDb->vgVersion++;

×

1130

    code = 0;

×

1133

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

×

1134

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

×

1135

    pDb->vgVersion++;

×

1136

    code = 0;

×

1139

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

×

1140

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

×

1141

    pDb->vgVersion++;

×

1142

    code = 0;

×

1145

  if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&

×

1146

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

×

1147

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

×

1148

    pDb->vgVersion++;

×

1149

    code = 0;

×

1152

  if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&

×

1153

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

×

1154

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

×

1155

    pDb->vgVersion++;

×

1156

    code = 0;

×

1159

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

×

1160

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

×

1161

    pDb->vgVersion++;

×

1162

    code = 0;

×

1165

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

×

1166

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

×

1167

    pDb->vgVersion++;

×

1168

    code = 0;

×

1171

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

×

1172

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

×

1173

    pDb->vgVersion++;

×

1174

    code = 0;

×

1177

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

×

1178

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

×

1179

    pDb->vgVersion++;

×

1180

    code = 0;

×

1183

  bool compactTimeRangeChanged = false;

×

1184

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

×

1185

      (pAlter->compactStartTime == TSDB_DEFAULT_COMPACT_START_TIME ||

×

1186

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

×

1187

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

×

1188

    compactTimeRangeChanged = true;

×

1189

    code = 0;

×

1192

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

×

1193

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

×

1194

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

×

1195

    compactTimeRangeChanged = true;

×

1196

    code = 0;

×

1198

  if(compactTimeRangeChanged) {

×

1199

    pDb->vgVersion++;

×

1202

  if (pAlter->compactTimeOffset >= TSDB_MIN_COMPACT_TIME_OFFSET &&

×

1203

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

×

1204

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

×

1205

    pDb->vgVersion++;

×

1206

    code = 0;

×

1209

  TAOS_RETURN(code);

×

1212

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

×

1213

  int32_t  code = 0;

×

1214

  SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);

×

1215

  if (pRedoRaw == NULL) {

×

1216

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1217

    if (terrno != 0) code = terrno;

×

1218

    TAOS_RETURN(code);

×

1220

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

×

1221

    sdbFreeRaw(pRedoRaw);

×

1222

    TAOS_RETURN(code);

×

1225

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

×

1226

    sdbFreeRaw(pRedoRaw);

×

1227

    TAOS_RETURN(code);

×

1229

  return 0;

×

1232

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

×

1233

  int32_t  code = 0;

×

1234

  SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);

×

1235

  if (pCommitRaw == NULL) {

×

1236

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1237

    if (terrno != 0) code = terrno;

×

1238

    TAOS_RETURN(code);

×

1240

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

×

1241

    sdbFreeRaw(pCommitRaw);

×

1242

    TAOS_RETURN(code);

×

1245

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

×

1246

    sdbFreeRaw(pCommitRaw);

×

1247

    TAOS_RETURN(code);

×

1249

  TAOS_RETURN(code);

×

1252

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

×

1253

  int32_t code = 0, lino = 0;

×

1254

  SSdb   *pSdb = pMnode->pSdb;

×

1255

  void   *pIter = NULL;

×

1256

  SVgObj *pVgroup = NULL;

×

1257

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

×

1259

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

×

1262

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

×

1263

    if (pIter == NULL) break;

×

1265

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

×

1266

      SVgObj newVgroup = {0};

×

1267

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

×

1270

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

×

1271

        if (pNewDb->cfg.withArbitrator) {

×

1272

          SArbGroup arbGroup = {0};

×

1273

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

×

1274

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

×

1276

          SArbGroup arbGroup = {0};

×

1277

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

×

1278

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

×

1283

    sdbRelease(pSdb, pVgroup);

×

1286

  taosArrayDestroy(pArray);

×

1287

  TAOS_RETURN(code);

×

1289

_err:

×

1290

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

×

1292

  sdbCancelFetch(pSdb, pIter);

×

1293

  sdbRelease(pSdb, pVgroup);

×

1294

  taosArrayDestroy(pArray);

×

1295

  TAOS_RETURN(code);

×

1298

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

×

1299

  int32_t code = -1;

×

1300

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

×

1301

  if (pTrans == NULL) {

×

1302

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1303

    if (terrno != 0) code = terrno;

×

1304

    TAOS_RETURN(code);

×

1306

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

×

1307

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

×

1309

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

×

1310

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

×

1311

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

×

1313

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

×

1314

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

×

1315

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

×

1317

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

×

1318

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

×

1319

  code = 0;

×

1321

_OVER:

×

1322

  mndTransDrop(pTrans);

×

1323

  TAOS_RETURN(code);

×

1326

static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {

×

1327

  SMnode     *pMnode = pReq->info.node;

×

1328

  int32_t     code = -1;

×

1329

  SDbObj     *pDb = NULL;

×

1330

  SAlterDbReq alterReq = {0};

×

1331

  SDbObj      dbObj = {0};

×

1333

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

×

1335

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

×

1337

  pDb = mndAcquireDb(pMnode, alterReq.db);

×

1338

  if (pDb == NULL) {

×

1339

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1340

    if (terrno != 0) code = terrno;

×

1341

    goto _OVER;

×

1344

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

×

1346

  if (alterReq.replications == 2) {

×

1347

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

×

1350

  int32_t numOfTopics = 0;

×

1351

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

×

1353

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

×

1354

    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;

×

1355

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

×

1357

    goto _OVER;

×

1360

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

×

1361

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

×

1362

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

×

1363

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

×

1366

  code = mndSetDbCfgFromAlterDbReq(&dbObj, &alterReq);

×

1367

  if (code != 0) {

×

1368

    if (code == TSDB_CODE_MND_DB_OPTION_UNCHANGED) code = 0;

×

1369

    goto _OVER;

×

1372

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

×

1374

  dbObj.cfgVersion++;

×

1375

  dbObj.updateTime = taosGetTimestampMs();

×

1376

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

×

1378

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

×

1380

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

×

1382

    if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1385

  SName name = {0};

×

1386

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

×

1387

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

×

1389

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

×

1391

_OVER:

×

1392

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

×

1393

    if (terrno != 0) code = terrno;

×

1394

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

×

1397

  mndReleaseDb(pMnode, pDb);

×

1398

  taosArrayDestroy(dbObj.cfg.pRetensions);

×

1399

  tFreeSAlterDbReq(&alterReq);

×

1401

  TAOS_RETURN(code);

×

1404

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

×

1405

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

×

1406

  cfgRsp->dbId = pDb->uid;

×

1407

  cfgRsp->cfgVersion = pDb->cfgVersion;

×

1408

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

×

1409

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

×

1410

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

×

1411

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

×

1412

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

×

1413

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

×

1414

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

×

1415

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

×

1416

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

×

1417

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

×

1418

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

×

1419

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

×

1420

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

×

1421

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

×

1422

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

×

1423

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

×

1424

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

×

1425

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

×

1426

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

×

1427

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

×

1428

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

×

1429

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

×

1430

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

×

1431

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

×

1432

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

×

1433

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

×

1434

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

×

1435

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

×

1436

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

×

1437

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

×

1438

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

×

1439

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

×

1440

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

×

1441

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

×

1442

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

×

1443

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

×

1444

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

×

1445

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

×

1446

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

×

1447

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

×

1448

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

×

1449

×

1451

static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {

×

1452

  SMnode   *pMnode = pReq->info.node;

×

1453

  int32_t   code = -1;

×

1454

  SDbObj   *pDb = NULL;

×

1455

  SDbCfgReq cfgReq = {0};

×

1456

  SDbCfgRsp cfgRsp = {0};

×

1458

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

×

1460

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

×

1461

    pDb = mndAcquireDb(pMnode, cfgReq.db);

×

1462

    if (pDb == NULL) {

×

1463

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1464

      if (terrno != 0) code = terrno;

×

1465

      goto _OVER;

×

1468

    mndDumpDbCfgInfo(&cfgRsp, pDb);

×

1471

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

×

1472

  void   *pRsp = rpcMallocCont(contLen);

×

1473

  if (pRsp == NULL) {

×

1474

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1475

    if (terrno != 0) code = terrno;

×

1476

    goto _OVER;

×

1479

  int32_t ret = 0;

×

1480

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

×

1481

    code = ret;

×

1482

    goto _OVER;

×

1485

  pReq->info.rsp = pRsp;

×

1486

  pReq->info.rspLen = contLen;

×

1488

  code = 0;

×

1490

_OVER:

×

1492

  tFreeSDbCfgRsp(&cfgRsp);

×

1494

  if (code != 0) {

×

1495

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

×

1498

  mndReleaseDb(pMnode, pDb);

×

1500

  TAOS_RETURN(code);

×

1503

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

×

1504

  int32_t  code = 0;

×

1505

  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);

×

1506

  if (pRedoRaw == NULL) {

×

1507

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1508

    if (terrno != 0) code = terrno;

×

1509

    return -1;

×

1511

  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));

×

1512

  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));

×

1514

  SSdb *pSdb = pMnode->pSdb;

×

1515

  void *pIter = NULL;

×

1517

  while (1) {

×

1518

    SArbGroup *pArbGroup = NULL;

×

1519

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

×

1520

    if (pIter == NULL) break;

×

1522

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

×

1523

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

×

1524

        sdbCancelFetch(pSdb, pIter);

×

1525

        sdbRelease(pSdb, pArbGroup);

×

1526

        TAOS_RETURN(code);

×

1530

    sdbRelease(pSdb, pArbGroup);

×

1533

  TAOS_RETURN(code);

×

1536

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

×

1537

  int32_t  code = 0;

×

1538

  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);

×

1539

  if (pCommitRaw == NULL) {

×

1540

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1541

    if (terrno != 0) code = terrno;

×

1542

    return -1;

×

1544

  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));

×

1545

  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));

×

1547

  SSdb *pSdb = pMnode->pSdb;

×

1548

  void *pIter = NULL;

×

1550

  while (1) {

×

1551

    SArbGroup *pArbGroup = NULL;

×

1552

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

×

1553

    if (pIter == NULL) break;

×

1555

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

×

1556

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

×

1557

        sdbCancelFetch(pSdb, pIter);

×

1558

        sdbRelease(pSdb, pArbGroup);

×

1559

        TAOS_RETURN(code);

×

1563

    sdbRelease(pSdb, pArbGroup);

×

1566

  while (1) {

×

1567

    SVgObj *pVgroup = NULL;

×

1568

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

×

1569

    if (pIter == NULL) break;

×

1571

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

×

1572

      SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);

×

1573

      if (pVgRaw == NULL) {

×

1574

        sdbCancelFetch(pSdb, pIter);

×

1575

        sdbRelease(pSdb, pVgroup);

×

1576

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1577

        if (terrno != 0) code = terrno;

×

1578

        TAOS_RETURN(code);

×

1580

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

×

1581

        sdbCancelFetch(pSdb, pIter);

×

1582

        sdbRelease(pSdb, pVgroup);

×

1583

        TAOS_RETURN(code);

×

1585

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

×

1586

        sdbCancelFetch(pSdb, pIter);

×

1587

        sdbRelease(pSdb, pVgroup);

×

1588

        TAOS_RETURN(code);

×

1592

    sdbRelease(pSdb, pVgroup);

×

1595

  while (1) {

×

1596

    SStbObj *pStb = NULL;

×

1597

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

×

1598

    if (pIter == NULL) break;

×

1600

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

×

1601

      SSdbRaw *pStbRaw = mndStbActionEncode(pStb);

×

1602

      if (pStbRaw == NULL) {

×

1603

        sdbCancelFetch(pSdb, pIter);

×

1604

        sdbRelease(pSdb, pStbRaw);

×

1605

        code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1606

        if (terrno != 0) code = terrno;

×

1607

        return -1;

×

1609

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

×

1610

        sdbCancelFetch(pSdb, pIter);

×

1611

        sdbRelease(pSdb, pStbRaw);

×

1612

        return -1;

×

1614

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

×

1615

        sdbCancelFetch(pSdb, pIter);

×

1616

        sdbRelease(pSdb, pStbRaw);

×

1617

        return -1;

×

1621

    sdbRelease(pSdb, pStb);

×

1624

  TAOS_RETURN(code);

×

1627

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

×

1628

  int32_t code = 0;

×

1629

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

×

1630

    SVnodeGid *pVgid = pVgroup->vnodeGid + vn;

×

1631

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

×

1634

  TAOS_RETURN(code);

×

1637

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

×

1638

  int32_t code = 0;

×

1639

  SSdb   *pSdb = pMnode->pSdb;

×

1640

  void   *pIter = NULL;

×

1642

  while (1) {

×

1643

    SVgObj *pVgroup = NULL;

×

1644

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

×

1645

    if (pIter == NULL) break;

×

1647

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

×

1648

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

×

1649

        sdbCancelFetch(pSdb, pIter);

×

1650

        sdbRelease(pSdb, pVgroup);

×

1651

        TAOS_RETURN(code);

×

1655

    sdbRelease(pSdb, pVgroup);

×

1658

  TAOS_RETURN(code);

×

1661

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

×

1662

  int32_t    code = 0;

×

1663

  SDropDbRsp dropRsp = {0};

×

1664

  if (pDb != NULL) {

×

1665

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

×

1666

    dropRsp.uid = pDb->uid;

×

1669

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

×

1670

  void   *pRsp = NULL;

×

1671

  if (useRpcMalloc) {

×

1672

    pRsp = rpcMallocCont(rspLen);

×

1674

    pRsp = taosMemoryMalloc(rspLen);

×

1677

  if (pRsp == NULL) {

×

1678

    code = terrno;

×

1679

    TAOS_RETURN(code);

×

1682

  int32_t ret = 0;

×

1683

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

×

1684

  *pRspLen = rspLen;

×

1685

  *ppRsp = pRsp;

×

1686

  TAOS_RETURN(code);

×

1689

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

×

1690

  int32_t code = -1;

×

1692

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

×

1693

  if (pTrans == NULL) {

×

1694

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1695

    if (terrno != 0) code = terrno;

×

1696

    goto _OVER;

×

1699

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

×

1701

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

×

1702

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

×

1704

  if (mndTopicExistsForDb(pMnode, pDb)) {

×

1705

    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;

×

1706

    goto _OVER;

×

1709

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

×

1710

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

×

1714

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

×

1716

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

×

1718

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

×

1719

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

×

1720

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

×

1721

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

×

1723

  int32_t rspLen = 0;

×

1724

  void   *pRsp = NULL;

×

1725

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

×

1726

  mndTransSetRpcRsp(pTrans, pRsp, rspLen);

×

1728

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

×

1729

  code = 0;

×

1731

_OVER:

×

1732

  mndTransDrop(pTrans);

×

1733

  TAOS_RETURN(code);

×

1736

static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {

×

1737

  SMnode    *pMnode = pReq->info.node;

×

1738

  int32_t    code = -1;

×

1739

  SDbObj    *pDb = NULL;

×

1740

  SDropDbReq dropReq = {0};

×

1742

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

×

1744

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

×

1746

  pDb = mndAcquireDb(pMnode, dropReq.db);

×

1747

  if (pDb == NULL) {

×

1748

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1749

    if (terrno != 0) code = terrno;

×

1750

    if (dropReq.ignoreNotExists) {

×

1751

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

×

1753

    goto _OVER;

×

1756

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

×

1758

  code = mndDropDb(pMnode, pReq, pDb);

×

1759

  if (code == TSDB_CODE_SUCCESS) {

×

1760

    code = TSDB_CODE_ACTION_IN_PROGRESS;

×

1763

  SName name = {0};

×

1764

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

×

1765

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

×

1767

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

×

1769

_OVER:

×

1770

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

×

1771

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

×

1774

  mndReleaseDb(pMnode, pDb);

×

1775

  tFreeSDropDbReq(&dropReq);

×

1776

  TAOS_RETURN(code);

×

1779

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

×

1780

  int32_t numOfTables = 0;

×

1781

  int32_t vindex = 0;

×

1782

  SSdb   *pSdb = pMnode->pSdb;

×

1784

  void *pIter = NULL;

×

1785

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

×

1786

    SVgObj *pVgroup = NULL;

×

1787

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

×

1788

    if (pIter == NULL) break;

×

1790

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

×

1791

      numOfTables += pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

1792

      vindex++;

×

1795

    sdbRelease(pSdb, pVgroup);

×

1798

  sdbCancelFetch(pSdb, pIter);

×

1799

  return numOfTables;

×

1802

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

×

1803

  int32_t vindex = 0;

×

1804

  SSdb   *pSdb = pMnode->pSdb;

×

1806

  void *pIter = NULL;

×

1807

  while (1) {

×

1808

    SVgObj *pVgroup = NULL;

×

1809

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

×

1810

    if (pIter == NULL) break;

×

1812

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

×

1813

      SVgroupInfo vgInfo = {0};

×

1814

      vgInfo.vgId = pVgroup->vgId;

×

1815

      vgInfo.hashBegin = pVgroup->hashBegin;

×

1816

      vgInfo.hashEnd = pVgroup->hashEnd;

×

1817

      vgInfo.numOfTable = pVgroup->numOfTables / TSDB_TABLE_NUM_UNIT;

×

1818

      vgInfo.epSet.numOfEps = pVgroup->replica;

×

1819

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

×

1820

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

×

1821

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

×

1822

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

×

1823

        if (pDnode != NULL) {

×

1824

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

×

1825

          pEp->port = pDnode->port;

×

1827

        mndReleaseDnode(pMnode, pDnode);

×

1828

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

×

1829

          vgInfo.epSet.inUse = gid;

×

1832

      vindex++;

×

1833

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

×

1834

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

×

1838

    sdbRelease(pSdb, pVgroup);

×

1840

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

×

1841

      sdbCancelFetch(pSdb, pIter);

×

1842

      break;

×

1845

×

1847

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

×

1848

  int32_t code = 0;

×

1849

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

×

1850

  if (pRsp->pVgroupInfos == NULL) {

×

1851

    code = terrno;

×

1852

    TAOS_RETURN(code);

×

1855

  int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

1857

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

×

1858

      pReq->stateTs < pDb->stateTs) {

×

1859

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

×

1862

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

×

1863

  pRsp->uid = pDb->uid;

×

1864

  pRsp->vgVersion = pDb->vgVersion;

×

1865

  pRsp->stateTs = pDb->stateTs;

×

1866

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

×

1867

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

×

1868

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

×

1869

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

×

1870

  TAOS_RETURN(code);

×

1873

static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {

×

1874

  SMnode   *pMnode = pReq->info.node;

×

1875

  int32_t   code = -1;

×

1876

  SDbObj   *pDb = NULL;

×

1877

  SUseDbReq usedbReq = {0};

×

1878

  SUseDbRsp usedbRsp = {0};

×

1880

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

×

1882

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

×

1883

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

×

1884

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

×

1885

    int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

1886

    if (usedbReq.vgVersion < vgVersion) {

×

1887

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

×

1888

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

×

1890

      mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);

×

1891

      usedbRsp.vgVersion = vgVersion++;

×

1893

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

1895

    usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);

×

1896

    code = 0;

×

1898

    pDb = mndAcquireDb(pMnode, usedbReq.db);

×

1899

    if (pDb == NULL) {

×

1900

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

×

1901

      usedbRsp.uid = usedbReq.dbId;

×

1902

      usedbRsp.vgVersion = usedbReq.vgVersion;

×

1903

      usedbRsp.errCode = terrno;

×

1905

      code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

1906

      if (terrno != 0) code = terrno;

×

1907

      goto _OVER;

×

1909

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

×

1911

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

×

1913

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

×

1915

      code = 0;

×

1919

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

×

1920

  void   *pRsp = rpcMallocCont(contLen);

×

1921

  if (pRsp == NULL) {

×

1922

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1923

    code = -1;

×

1924

    goto _OVER;

×

1927

  int32_t ret = 0;

×

1928

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

×

1929

    code = ret;

×

1930

    goto _OVER;

×

1933

  pReq->info.rsp = pRsp;

×

1934

  pReq->info.rspLen = contLen;

×

1936

_OVER:

×

1937

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

×

1938

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

×

1941

  mndReleaseDb(pMnode, pDb);

×

1942

  tFreeSUsedbRsp(&usedbRsp);

×

1944

  TAOS_RETURN(code);

×

1947

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

×

1948

  int32_t       code = 0;

×

1949

  SDbHbBatchRsp batchRsp = {0};

×

1950

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

×

1951

  if (batchRsp.pArray == NULL) {

×

1952

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

1953

    TAOS_RETURN(code);

×

1956

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

×

1957

    SDbCacheInfo *pDbCacheInfo = &pDbs[i];

×

1958

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

×

1959

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

×

1960

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

×

1961

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

×

1962

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

×

1963

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

×

1965

    SDbHbRsp rsp = {0};

×

1966

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

×

1967

    rsp.dbId = pDbCacheInfo->dbId;

×

1969

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

×

1970

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

×

1971

      int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);

×

1972

      if (pDbCacheInfo->vgVersion >= vgVersion) {

×

1973

        continue;

×

1976

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

×

1977

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

×

1978

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

×

1980

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

×

1981

      rsp.useDbRsp->vgVersion = vgVersion++;

×

1983

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

×

1985

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

×

1986

        if (terrno != 0) code = terrno;

×

1987

        return code;

×

1990

      continue;

×

1993

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

×

1994

    if (pDb == NULL) {

×

1995

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

×

1996

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

×

1997

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

×

1998

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

×

1999

      rsp.useDbRsp->vgVersion = -1;

×

2000

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

×

2001

        if (terrno != 0) code = terrno;

×

2002

        return code;

×

2004

      continue;

×

2007

    int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);

×

2009

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

×

2010

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

×

2011

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

×

2012

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

×

2016

      mndReleaseDb(pMnode, pDb);

×

2017

      continue;

×

2019

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

×

2025

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

×

2026

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

×

2027

      mndDumpDbCfgInfo(rsp.cfgRsp, pDb);

×

2030

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

×

2031

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

×

2032

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

×

2033

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

×

2034

        bool    exist = false;

×

2035

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

×

2036

        if (TSDB_CODE_SUCCESS != code) {

×

2037

          mndReleaseDb(pMnode, pDb);

×

2038

          if (code != TSDB_CODE_NEED_RETRY) {

×

2039

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

×

2041

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

×

2043

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

×

2044

          taosMemoryFreeClear(rsp.pTsmaRsp);

×

2045

          continue;

×

2047

        rsp.dbTsmaVersion = pDb->tsmaVersion;

×

2048

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

×

2052

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

×

2053

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

×

2054

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

×

2055

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

×

2056

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

×

2057

        mndReleaseDb(pMnode, pDb);

×

2058

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

×

2059

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

×

2060

        taosMemoryFreeClear(rsp.pTsmaRsp);

×

2061

        continue;

×

2064

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

×

2065

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

×

2066

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

×

2067

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

×

2068

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

×

2069

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

×

2070

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

×

2071

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

×

2072

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

×

2075

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

×

2076

      mndReleaseDb(pMnode, pDb);

×

2077

      if (terrno != 0) code = terrno;

×

2078

      return code;

×

2080

    mndReleaseDb(pMnode, pDb);

×

2083

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

×

2084

  void   *pRsp = taosMemoryMalloc(rspLen);

×

2085

  if (pRsp == NULL) {

×

2086

    terrno = TSDB_CODE_OUT_OF_MEMORY;

×

2087

    tFreeSDbHbBatchRsp(&batchRsp);

×

2088

    return -1;

×

2090

  int32_t ret = 0;

×

2091

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

×

2093

  *ppRsp = pRsp;

×

2094

  *pRspLen = rspLen;

×

2096

  tFreeSDbHbBatchRsp(&batchRsp);

×

2097

  TAOS_RETURN(code);

×

2100

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

×

2101

  SSdb       *pSdb = pMnode->pSdb;

×

2102

  SVgObj     *pVgroup = NULL;

×

2103

  void       *pIter = NULL;

×

2104

  int32_t     code = 0;

×

2105

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

×

2106

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

×

2107

  int32_t     contLen = reqLen + sizeof(SMsgHead);

×

2109

  while (1) {

×

2110

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

×

2111

    if (pIter == NULL) break;

×

2113

    SMsgHead *pHead = rpcMallocCont(contLen);

×

2114

    if (pHead == NULL) {

×

2115

      sdbCancelFetch(pSdb, pVgroup);

×

2116

      sdbRelease(pSdb, pVgroup);

×

2117

      continue;

×

2119

    pHead->contLen = htonl(contLen);

×

2120

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

×

2121

    int32_t ret = 0;

×

2122

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

×

2123

      sdbRelease(pSdb, pVgroup);

×

2124

      return ret;

×

2127

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

×

2128

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

2129

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

×

2130

    if (code != 0) {

×

2131

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

×

2133

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

×

2135

    sdbRelease(pSdb, pVgroup);

×

2138

  return 0;

×

2141

static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {

×

2142

  SMnode    *pMnode = pReq->info.node;

×

2143

  int32_t    code = -1;

×

2144

  SDbObj    *pDb = NULL;

×

2145

  STrimDbReq trimReq = {0};

×

2147

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

×

2149

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

×

2151

  pDb = mndAcquireDb(pMnode, trimReq.db);

×

2152

  if (pDb == NULL) {

×

2153

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2154

    if (terrno != 0) code = terrno;

×

2155

    goto _OVER;

×

2158

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

×

2160

  code = mndTrimDb(pMnode, pDb);

×

2162

_OVER:

×

2163

  if (code != 0) {

×

2164

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

×

2167

  mndReleaseDb(pMnode, pDb);

×

2168

  TAOS_RETURN(code);

×

2171

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

×

2172

  SSdb            *pSdb = pMnode->pSdb;

×

2173

  SVgObj          *pVgroup = NULL;

×

2174

  void            *pIter = NULL;

×

2175

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

×

2176

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

×

2177

  int32_t          contLen = reqLen + sizeof(SMsgHead);

×

2178

  int32_t          code = 0;

×

2180

  while (1) {

×

2181

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

×

2182

    if (pIter == NULL) break;

×

2184

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

×

2186

    SMsgHead *pHead = rpcMallocCont(contLen);

×

2187

    if (pHead == NULL) {

×

2188

      sdbCancelFetch(pSdb, pVgroup);

×

2189

      sdbRelease(pSdb, pVgroup);

×

2190

      continue;

×

2192

    pHead->contLen = htonl(contLen);

×

2193

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

×

2194

    int32_t ret = 0;

×

2195

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

×

2196

      sdbRelease(pSdb, pVgroup);

×

2197

      return ret;

×

2200

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

×

2201

    SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);

×

2202

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

×

2203

    if (code != 0) {

×

2204

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

×

2206

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

×

2208

    sdbRelease(pSdb, pVgroup);

×

2211

  return 0;

×

2214

static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq) {

×

2215

  SMnode         *pMnode = pReq->info.node;

×

2216

  int32_t         code = -1;

×

2217

  SDbObj         *pDb = NULL;

×

2218

  SS3MigrateDbReq s3migrateReq = {0};

×

2220

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

×

2222

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

×

2224

  pDb = mndAcquireDb(pMnode, s3migrateReq.db);

×

2225

  if (pDb == NULL) {

×

2226

    code = TSDB_CODE_MND_RETURN_VALUE_NULL;

×

2227

    if (terrno != 0) code = terrno;

×

2228

    goto _OVER;

×

2231

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

×

2233

  code = mndS3MigrateDb(pMnode, pDb);

×

2235

_OVER:

×

2236

  if (code != 0) {

×

2237

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

×

2240

  mndReleaseDb(pMnode, pDb);

×

2241

  TAOS_RETURN(code);

×

2244

const char *mndGetDbStr(const char *src) {

×

2245

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

2246

  if (pos != NULL) ++pos;

×

2247

  if (pos == NULL) return src;

×

2248

  return pos;

×

2251

const char *mndGetStableStr(const char *src) {

×

2252

  char *pos = strstr(src, TS_PATH_DELIMITER);

×

2253

  if (pos != NULL) ++pos;

×

2254

  if (pos == NULL) return src;

×

2255

  return mndGetDbStr(pos);

×

2258

static int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {

×

2259

  int64_t v = 0;

×

2260

  switch (unit) {

×

2261

    case 's':

×

2262

      v = val / 1000;

×

2263

      break;

×

2264

    case 'm':

×

2265

      v = val / tsTickPerMin[TSDB_TIME_PRECISION_MILLI];

×

2266

      break;

×

2267

    case 'h':

×

2268

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

×

2269

      break;

×

2270

    case 'd':

×

2271

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

×

2272

      break;

×

2273

    case 'w':

×

2274

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

×

2275

      break;

×

2276

    default:

×

2277

      break;

×

2280

  return v;

×

2283

static char *buildRetension(SArray *pRetension) {

×

2284

  size_t size = taosArrayGetSize(pRetension);

×

2285

  if (size == 0) {

×

2286

    return NULL;

×

2289

  char       *p1 = taosMemoryCalloc(1, 100);

×

2290

  SRetention *p = taosArrayGet(pRetension, 0);

×

2292

  int32_t len = 2;

×

2294

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

×

2295

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

×

2296

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

×

2298

  if (size > 1) {

×

2299

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

×

2300

    p = taosArrayGet(pRetension, 1);

×

2302

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

×

2303

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

×

2304

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

×

2307

  if (size > 2) {

×

2308

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

×

2309

    p = taosArrayGet(pRetension, 2);

×

2311

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

×

2312

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

×

2313

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

×

2316

  varDataSetLen(p1, len);

×

2317

  return p1;

×

2320

static const char *getCacheModelStr(int8_t cacheModel) {

×

2321

  switch (cacheModel) {

×

2322

    case TSDB_CACHE_MODEL_NONE:

×

2323

      return TSDB_CACHE_MODEL_NONE_STR;

×

2324

    case TSDB_CACHE_MODEL_LAST_ROW:

×

2325

      return TSDB_CACHE_MODEL_LAST_ROW_STR;

×

2326

    case TSDB_CACHE_MODEL_LAST_VALUE:

×

2327

      return TSDB_CACHE_MODEL_LAST_VALUE_STR;

×

2328

    case TSDB_CACHE_MODEL_BOTH:

×

2329

      return TSDB_CACHE_MODEL_BOTH_STR;

×

2330

    default:

×

2331

      break;

×

2333

  return "unknown";

×

2336

static const char *getEncryptAlgorithmStr(int8_t encryptAlgorithm) {

×

2337

  switch (encryptAlgorithm) {

×

2338

    case TSDB_ENCRYPT_ALGO_NONE:

×

2339

      return TSDB_ENCRYPT_ALGO_NONE_STR;

×

2340

    case TSDB_ENCRYPT_ALGO_SM4:

×

2341

      return TSDB_ENCRYPT_ALGO_SM4_STR;

×

2342

    default:

×

2343

      break;

×

2345

  return "unknown";

×

2348

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

×

2349

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

×

2351

  SSdb *pSdb = pMnode->pSdb;

×

2352

  void *pIter = NULL;

×

2353

  bool  isReady = true;

×

2354

  while (1) {

×

2355

    SVgObj *pVgroup = NULL;

×

2356

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

×

2357

    if (pIter == NULL) break;

×

2359

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

×

2360

      bool hasLeader = false;

×

2361

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

×

2362

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

×

2363

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

×

2364

          hasLeader = true;

×

2367

      if (!hasLeader) isReady = false;

×

2369

    sdbRelease(pSdb, pVgroup);

×

2372

  return isReady;

×

2375

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

×

2377

  int32_t cols = 0;

×

2378

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

×

2379

  char   *buf = taosMemoryMalloc(bytes);

×

2380

  if (buf == NULL) {

×

2381

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

×

2382

    return;

×

2384

  int32_t code = 0;

×

2385

  int32_t lino = 0;

×

2387

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

×

2388

  if (name != NULL) {

×

2389

    STR_WITH_MAXSIZE_TO_VARSTR(buf, name, bytes);

×

2391

    STR_WITH_MAXSIZE_TO_VARSTR(buf, "NULL", bytes);

×

2394

  const char *precStr = NULL;

×

2395

  switch (pDb->cfg.precision) {

×

2396

    case TSDB_TIME_PRECISION_MILLI:

×

2397

      precStr = TSDB_TIME_PRECISION_MILLI_STR;

×

2398

      break;

×

2399

    case TSDB_TIME_PRECISION_MICRO:

×

2400

      precStr = TSDB_TIME_PRECISION_MICRO_STR;

×

2401

      break;

×

2402

    case TSDB_TIME_PRECISION_NANO:

×

2403

      precStr = TSDB_TIME_PRECISION_NANO_STR;

×

2404

      break;

×

2405

    default:

×

2406

      precStr = "none";

×

2407

      break;

×

2409

  char precVstr[10] = {0};

×

2410

  STR_WITH_MAXSIZE_TO_VARSTR(precVstr, precStr, 10);

×

2412

  char *statusStr = "ready";

×

2413

  if (objStatus == SDB_STATUS_CREATING) {

×

2414

    statusStr = "creating";

×

2415

  } else if (objStatus == SDB_STATUS_DROPPING) {

×

2416

    statusStr = "dropping";

×

2418

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

×

2419

      statusStr = "unsynced";

×

2422

  char statusVstr[24] = {0};

×

2423

  STR_WITH_MAXSIZE_TO_VARSTR(statusVstr, statusStr, 24);

×

2425

  if (sysDb || !sysinfo) {

×

2426

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

×

2427

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

×

2428

      if (i == 0) {

×

2429

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

×

2430

      } else if (i == 1) {

×

2431

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

×

2432

      } else if (i == 3) {

×

2433

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

×

2434

      } else if (i == 14) {

×

2435

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

×

2436

      } else if (i == 15) {

×

2437

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

×

2439

        colDataSetNULL(pColInfo, rows);

×

2443

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

×

2444

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

×

2446

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

×

2447

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

×

2449

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

×

2450

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

×

2452

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

×

2453

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

×

2455

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

×

2456

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

×

2458

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

×

2459

    char        strictVstr[24] = {0};

×

2460

    STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);

×

2461

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

×

2462

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

×

2464

    char    durationStr[128] = {0};

×

2465

    char    durationVstr[128] = {0};

×

2466

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

×

2469

    varDataSetLen(durationVstr, len);

×

2470

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

×

2471

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

×

2473

    char keepVstr[128] = {0};

×

2474

    char keep0Str[32] = {0};

×

2475

    char keep1Str[32] = {0};

×

2476

    char keep2Str[32] = {0};

×

2478

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

×

2479

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

×

2480

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

×

2482

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

×

2483

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

×

2485

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

×

2487

    varDataSetLen(keepVstr, len);

×

2488

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

×

2489

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

×

2491

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

×

2492

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

×

2494

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

×

2495

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

×

2497

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

×

2498

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

×

2500

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

×

2501

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

×

2503

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

×

2504

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

×

2506

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

×

2507

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

×

2509

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

×

2510

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

×

2512

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

×

2513

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

×

2515

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

×

2516

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

×

2517

    if (rentensionVstr == NULL) {

×

2518

      colDataSetNULL(pColInfo, rows);

×

2520

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

×

2521

      taosMemoryFree(rentensionVstr);

×

2524

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

×

2525

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

×

2527

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

×

2528

    char        cacheModelVstr[24] = {0};

×

2529

    STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);

×

2530

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

×

2531

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

×

2533

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

×

2534

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

×

2536

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

×

2537

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

×

2539

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

×

2540

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

×

2542

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

×

2543

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

×

2545

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

×

2546

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

×

2548

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

×

2549

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

×

2551

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

×

2552

    int16_t hashPrefix = pDb->cfg.hashPrefix;

×

2553

    if (hashPrefix > 0) {

×

2554

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

×

2555

    } else if (hashPrefix < 0) {

×

2556

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

×

2558

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

×

2560

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

×

2561

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

×

2563

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

×

2564

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false), &lino, _OVER);

×

2566

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2567

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false), &lino, _OVER);

×

2569

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2570

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false), &lino, _OVER);

×

2572

    char keeplocalVstr[128] = {0};

×

2573

    len = tsnprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], sizeof(keeplocalVstr), "%dm", pDb->cfg.s3KeepLocal);

×

2574

    varDataSetLen(keeplocalVstr, len);

×

2575

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2576

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false), &lino, _OVER);

×

2578

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2579

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false), &lino, _OVER);

×

2581

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2582

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false), &lino, _OVER);

×

2584

    const char *encryptAlgorithmStr = getEncryptAlgorithmStr(pDb->cfg.encryptAlgorithm);

×

2585

    char        encryptAlgorithmVStr[24] = {0};

×

2586

    STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);

×

2587

    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

×

2588

    TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false), &lino, _OVER);

×

2590

    TAOS_UNUSED(formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactInterval));

×

2591

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2592

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

×

2593

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

2596

    len = formatDurationOrKeep(durationStr, sizeof(durationStr), pDb->cfg.compactStartTime);

×

2597

    TAOS_UNUSED(formatDurationOrKeep(durationVstr, sizeof(durationVstr), pDb->cfg.compactEndTime));

×

2598

    TAOS_UNUSED(snprintf(durationStr + len, sizeof(durationStr) - len, ",%s", durationVstr));

×

2599

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2600

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

×

2601

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

2604

    TAOS_UNUSED(snprintf(durationStr, sizeof(durationStr), "%dh", pDb->cfg.compactTimeOffset));

×

2605

    STR_WITH_MAXSIZE_TO_VARSTR(durationVstr, durationStr, sizeof(durationVstr));

×

2606

    if ((pColInfo = taosArrayGet(pBlock->pDataBlock, cols++))) {

×

2607

      TAOS_CHECK_GOTO(colDataSetVal(pColInfo, rows, (const char *)durationVstr, false), &lino, _OVER);

×

2610

_OVER:

×

2611

  if (code != 0) mError("failed to retrieve at line:%d, since %s", lino, tstrerror(code));

×

2612

  taosMemoryFree(buf);

×

2615

static void setInformationSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

2616

  tstrncpy(pDbObj->name, TSDB_INFORMATION_SCHEMA_DB, tListLen(pDbObj->name));

×

2617

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

2618

  pDbObj->cfg.numOfVgroups = 0;

×

2619

  pDbObj->cfg.strict = 1;

×

2620

  pDbObj->cfg.replications = 1;

×

2621

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

2622

×

2624

static void setPerfSchemaDbCfg(SMnode *pMnode, SDbObj *pDbObj) {

×

2625

  tstrncpy(pDbObj->name, TSDB_PERFORMANCE_SCHEMA_DB, tListLen(pDbObj->name));

×

2626

  pDbObj->createdTime = mndGetClusterCreateTime(pMnode);

×

2627

  pDbObj->cfg.numOfVgroups = 0;

×

2628

  pDbObj->cfg.strict = 1;

×

2629

  pDbObj->cfg.replications = 1;

×

2630

  pDbObj->cfg.precision = TSDB_TIME_PRECISION_MILLI;

×

2631

×

2633

static bool mndGetTablesOfDbFp(SMnode *pMnode, void *pObj, void *p1, void *p2, void *p3) {

×

2634

  SVgObj  *pVgroup = pObj;

×

2635

  int32_t *numOfTables = p1;

×

2636

  int64_t  uid = *(int64_t *)p2;

×

2637

  if (pVgroup->dbUid == uid) {

×

2638

    *numOfTables += pVgroup->numOfTables;

×

2640

  return true;

×

2643

static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {

×

2644

  SMnode    *pMnode = pReq->info.node;

×

2645

  SSdb      *pSdb = pMnode->pSdb;

×

2646

  int32_t    numOfRows = 0;

×

2647

  SDbObj    *pDb = NULL;

×

2648

  SUserObj  *pUser = NULL;

×

2649

  ESdbStatus objStatus = 0;

×

2651

  (void)mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);

×

2652

  if (pUser == NULL) return 0;

×

2653

  bool sysinfo = pUser->sysInfo;

×

2656

  if (!pShow->sysDbRsp) {

×

2657

    SDbObj infoschemaDb = {0};

×

2658

    setInformationSchemaDbCfg(pMnode, &infoschemaDb);

×

2659

    size_t numOfTables = 0;

×

2660

    getVisibleInfosTablesNum(sysinfo, &numOfTables);

×

2661

    mndDumpDbInfoData(pMnode, pBlock, &infoschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

2663

    numOfRows += 1;

×

2665

    SDbObj perfschemaDb = {0};

×

2666

    setPerfSchemaDbCfg(pMnode, &perfschemaDb);

×

2667

    numOfTables = 0;

×

2668

    getPerfDbMeta(NULL, &numOfTables);

×

2669

    mndDumpDbInfoData(pMnode, pBlock, &perfschemaDb, pShow, numOfRows, numOfTables, true, 0, 1);

×

2671

    numOfRows += 1;

×

2672

    pShow->sysDbRsp = true;

×

2675

  while (numOfRows < rowsCapacity) {

×

2676

    pShow->pIter = sdbFetchAll(pSdb, SDB_DB, pShow->pIter, (void **)&pDb, &objStatus, true);

×

2677

    if (pShow->pIter == NULL) break;

×

2679

    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) == 0) {

×

2680

      int32_t numOfTables = 0;

×

2681

      sdbTraverse(pSdb, SDB_VGROUP, mndGetTablesOfDbFp, &numOfTables, &pDb->uid, NULL);

×

2682

      mndDumpDbInfoData(pMnode, pBlock, pDb, pShow, numOfRows, numOfTables, false, objStatus, sysinfo);

×

2683

      numOfRows++;

×

2686

    sdbRelease(pSdb, pDb);

×

2689

  pShow->numOfRows += numOfRows;

×

2690

  mndReleaseUser(pMnode, pUser);

×

2691

  return numOfRows;

×

2694

static void mndCancelGetNextDb(SMnode *pMnode, void *pIter) {

×

2695

  SSdb *pSdb = pMnode->pSdb;

×

2696

  sdbCancelFetchByType(pSdb, pIter, SDB_DB);

×

2697

×

taosdata / TDengine / #3599

Source File
Press 'n' to go to next uncovered line, 'b' for previous

taosdata / TDengine / #3599

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