diff --git a/include/common/taosmsg.h b/include/common/taosmsg.h
index 22b8929c0f75a7a27ffedd367a5fc82106dab5f7..2b2383d0cd6fd5829938f206579635bbd1bc5bad 100644
--- a/include/common/taosmsg.h
+++ b/include/common/taosmsg.h
@@ -567,7 +567,6 @@ typedef struct {
   char    db[TSDB_FULL_DB_NAME_LEN];
   int32_t cacheBlockSize;  // MB
   int32_t totalBlocks;
-  int32_t maxTables;
   int32_t daysPerFile;
   int32_t daysToKeep0;
   int32_t daysToKeep1;
@@ -576,18 +575,51 @@ typedef struct {
   int32_t maxRowsPerFileBlock;
   int32_t commitTime;
   int32_t fsyncPeriod;
+  int8_t  walLevel;
   int8_t  precision;  // time resolution
   int8_t  compression;
-  int8_t  walLevel;
   int8_t  replications;
   int8_t  quorum;
-  int8_t  ignoreExist;
   int8_t  update;
   int8_t  cacheLastRow;
-  int8_t  dbType;
-  int16_t partitions;
-  int8_t  reserve[5];
-} SCreateDbMsg, SAlterDbMsg;
+  int8_t  ignoreExist;
+  int32_t reserve[8];
+} SCreateDbMsg;
+
+typedef struct {
+  char    db[TSDB_FULL_DB_NAME_LEN];
+  int32_t totalBlocks;
+  int32_t daysToKeep0;
+  int32_t daysToKeep1;
+  int32_t daysToKeep2;
+  int32_t fsyncPeriod;
+  int8_t  walLevel;
+  int8_t  quorum;
+  int8_t  cacheLastRow;
+  int32_t reserve[8];
+} SAlterDbMsg;
+
+typedef struct {
+  char    db[TSDB_TABLE_FNAME_LEN];
+  int8_t  ignoreNotExists;
+  int32_t reserve[8];
+} SDropDbMsg;
+
+typedef struct {
+  char    db[TSDB_TABLE_FNAME_LEN];
+  int8_t  ignoreNotExists;
+  int32_t reserve[8];
+} SUseDbMsg;
+
+typedef struct {
+  char    db[TSDB_TABLE_FNAME_LEN];
+  int32_t reserve[8];
+} SSyncDbMsg;
+
+typedef struct {
+  char    db[TSDB_TABLE_FNAME_LEN];
+  int32_t reserve[8];
+} SCompactDbMsg;
 
 typedef struct {
   char    name[TSDB_FUNC_NAME_LEN];
@@ -631,11 +663,6 @@ typedef struct {
   char    pFuncInfos[];
 } SRetrieveFuncRsp;
 
-typedef struct {
-  char   db[TSDB_TABLE_FNAME_LEN];
-  int8_t ignoreNotExists;
-} SDropDbMsg, SUseDbMsg, SSyncDbMsg;
-
 typedef struct {
   int32_t statusInterval;
   int32_t mnodeEqualVnodeNum;
diff --git a/include/dnode/mnode/sdb/sdb.h b/include/dnode/mnode/sdb/sdb.h
index 17ce5c952b92ab75a69dfb60c39db7e6707ad90a..d1f7d9a958d93266b47d4b81d5093b14819169de 100644
--- a/include/dnode/mnode/sdb/sdb.h
+++ b/include/dnode/mnode/sdb/sdb.h
@@ -65,6 +65,16 @@ extern "C" {
     dataPos += valLen;                                      \
   }
 
+#define SDB_GET_RESERVE(pRaw, pRow, dataPos, valLen)        \
+  {                                                         \
+    char val[valLen] = {0};                                 \
+    if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
+      sdbFreeRow(pRow);                                     \
+      return NULL;                                          \
+    }                                                       \
+    dataPos += valLen;                                      \
+  }
+
 #define SDB_SET_INT64(pRaw, dataPos, val)          \
   {                                                \
     if (sdbSetRawInt64(pRaw, dataPos, val) != 0) { \
@@ -110,6 +120,16 @@ extern "C" {
     dataPos += valLen;                                      \
   }
 
+#define SDB_SET_RESERVE(pRaw, dataPos, valLen)              \
+  {                                                         \
+    char val[valLen] = {0};                                 \
+    if (sdbSetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
+      sdbFreeRaw(pRaw);                                     \
+      return NULL;                                          \
+    }                                                       \
+    dataPos += valLen;                                      \
+  }
+
 #define SDB_SET_DATALEN(pRaw, dataLen)          \
   {                                             \
     if (sdbSetRawDataLen(pRaw, dataLen) != 0) { \
diff --git a/include/util/taoserror.h b/include/util/taoserror.h
index c0f7d8d32832d0c9419062cb1a94b2472d6c7756..39efdb3d042e0a138ca06067dd4e4f1eee56ccd6 100644
--- a/include/util/taoserror.h
+++ b/include/util/taoserror.h
@@ -211,22 +211,30 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_MND_INVALID_TAG_LENGTH        TAOS_DEF_ERROR_CODE(0, 0x0376)  //"invalid tag length")
 #define TSDB_CODE_MND_INVALID_COLUMN_LENGTH     TAOS_DEF_ERROR_CODE(0, 0x0377)   //"invalid column length")
 
-#define TSDB_CODE_MND_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0380)  //"Database not specified or available")
-#define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0381)  //"Database already exists")
-#define TSDB_CODE_MND_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x0382)  //"Invalid database options")
-#define TSDB_CODE_MND_INVALID_DB                TAOS_DEF_ERROR_CODE(0, 0x0383)  //"Invalid database name")
-#define TSDB_CODE_MND_MONITOR_DB_FORBIDDEN      TAOS_DEF_ERROR_CODE(0, 0x0384)  //"Cannot delete monitor database")
+#define TSDB_CODE_MND_DB_NOT_SELECTED           TAOS_DEF_ERROR_CODE(0, 0x0380)
+#define TSDB_CODE_MND_DB_NOT_EXIST              TAOS_DEF_ERROR_CODE(0, 0x0381) 
+#define TSDB_CODE_MND_DB_ALREADY_EXIST          TAOS_DEF_ERROR_CODE(0, 0x0381)
+#define TSDB_CODE_MND_INVALID_DB                TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_OPTION         TAOS_DEF_ERROR_CODE(0, 0x0382)
+#define TSDB_CODE_MND_INVALID_DB_CACHE_SIZE     TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS   TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_DAYS           TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_KEEP0          TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_KEEP1          TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_KEEP2          TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_MIN_ROWS       TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_MAX_ROWS       TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_COMMIT_TIME    TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD   TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_WAL_LEVEL      TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_PRECISION      TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_COMP           TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_REPLICA        TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_QUORUM         TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_UPDATE         TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_INVALID_DB_CACHE_LAST     TAOS_DEF_ERROR_CODE(0, 0x0383)
+#define TSDB_CODE_MND_DB_OPTION_UNCHANGED       TAOS_DEF_ERROR_CODE(0, 0x0383)
 #define TSDB_CODE_MND_TOO_MANY_DATABASES        TAOS_DEF_ERROR_CODE(0, 0x0385)  //"Too many databases for account")
-#define TSDB_CODE_MND_DB_IN_DROPPING            TAOS_DEF_ERROR_CODE(0, 0x0386)  //"Database not available")
-#define TSDB_CODE_MND_VGROUP_NOT_READY          TAOS_DEF_ERROR_CODE(0, 0x0387)  //"Database unsynced")
-
-#define TSDB_CODE_MND_INVALID_DB_OPTION_DAYS    TAOS_DEF_ERROR_CODE(0, 0x0390)  //"Invalid database option: days out of range")
-#define TSDB_CODE_MND_INVALID_DB_OPTION_KEEP    TAOS_DEF_ERROR_CODE(0, 0x0391)  //"Invalid database option: keep >= keep1 >= keep0 >= days")
-
-#define TSDB_CODE_MND_INVALID_TOPIC             TAOS_DEF_ERROR_CODE(0, 0x0392)  //"Invalid topic name)
-#define TSDB_CODE_MND_INVALID_TOPIC_OPTION      TAOS_DEF_ERROR_CODE(0, 0x0393)  //"Invalid topic option)
-#define TSDB_CODE_MND_INVALID_TOPIC_PARTITONS   TAOS_DEF_ERROR_CODE(0, 0x0394)  //"Invalid topic partitons num, valid range: [1, 1000])
-#define TSDB_CODE_MND_TOPIC_ALREADY_EXIST       TAOS_DEF_ERROR_CODE(0, 0x0395)  //"Topic already exists)
 
 // dnode
 #define TSDB_CODE_DND_ACTION_IN_PROGRESS        TAOS_DEF_ERROR_CODE(0, 0x0400)
diff --git a/include/util/tdef.h b/include/util/tdef.h
index 165c27067cf4b39664ceaa8fcb5c218306a8a831..3ab515671ab37d26f715a3fb7b037fdfe8bbbd30 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -250,12 +250,6 @@ do { \
 #define TSDB_MAX_TOTAL_BLOCKS           10000
 #define TSDB_DEFAULT_TOTAL_BLOCKS       6
 
-#define TSDB_MIN_TABLES                 4
-#define TSDB_MAX_TABLES                 10000000
-#define TSDB_DEFAULT_TABLES             1000000
-#define TSDB_TABLES_STEP                1000
-#define TSDB_META_COMPACT_RATIO         0       // disable tsdb meta compact by default
-
 #define TSDB_MIN_DAYS_PER_FILE          1
 #define TSDB_MAX_DAYS_PER_FILE          3650 
 #define TSDB_DEFAULT_DAYS_PER_FILE      10
@@ -264,18 +258,26 @@ do { \
 #define TSDB_MAX_KEEP                   365000   // data in db to be reserved.
 #define TSDB_DEFAULT_KEEP               3650     // ten years
 
-#define TSDB_DEFAULT_MIN_ROW_FBLOCK     100
 #define TSDB_MIN_MIN_ROW_FBLOCK         10
 #define TSDB_MAX_MIN_ROW_FBLOCK         1000
+#define TSDB_DEFAULT_MIN_ROW_FBLOCK     100
 
-#define TSDB_DEFAULT_MAX_ROW_FBLOCK     4096
 #define TSDB_MIN_MAX_ROW_FBLOCK         200
 #define TSDB_MAX_MAX_ROW_FBLOCK         10000
+#define TSDB_DEFAULT_MAX_ROW_FBLOCK     4096
 
 #define TSDB_MIN_COMMIT_TIME            30
 #define TSDB_MAX_COMMIT_TIME            40960
 #define TSDB_DEFAULT_COMMIT_TIME        3600
 
+#define TSDB_MIN_FSYNC_PERIOD           0
+#define TSDB_MAX_FSYNC_PERIOD           180000   // millisecond
+#define TSDB_DEFAULT_FSYNC_PERIOD       3000     // three second
+
+#define TSDB_MIN_WAL_LEVEL              0
+#define TSDB_MAX_WAL_LEVEL              2
+#define TSDB_DEFAULT_WAL_LEVEL          1
+
 #define TSDB_MIN_PRECISION              TSDB_TIME_PRECISION_MILLI
 #define TSDB_MAX_PRECISION              TSDB_TIME_PRECISION_NANO
 #define TSDB_DEFAULT_PRECISION          TSDB_TIME_PRECISION_MILLI
@@ -284,9 +286,13 @@ do { \
 #define TSDB_MAX_COMP_LEVEL             2
 #define TSDB_DEFAULT_COMP_LEVEL         2
 
-#define TSDB_MIN_WAL_LEVEL              0
-#define TSDB_MAX_WAL_LEVEL              2
-#define TSDB_DEFAULT_WAL_LEVEL          1
+#define TSDB_MIN_DB_REPLICA_OPTION      1
+#define TSDB_MAX_DB_REPLICA_OPTION      3
+#define TSDB_DEFAULT_DB_REPLICA_OPTION  1
+
+#define TSDB_MIN_DB_QUORUM_OPTION       1
+#define TSDB_MAX_DB_QUORUM_OPTION       2
+#define TSDB_DEFAULT_DB_QUORUM_OPTION   1
 
 #define TSDB_MIN_DB_UPDATE              0
 #define TSDB_MAX_DB_UPDATE              2
@@ -296,22 +302,6 @@ do { \
 #define TSDB_MAX_DB_CACHE_LAST_ROW      3
 #define TSDB_DEFAULT_CACHE_LAST_ROW     0
 
-#define TSDB_MIN_FSYNC_PERIOD           0
-#define TSDB_MAX_FSYNC_PERIOD           180000   // millisecond
-#define TSDB_DEFAULT_FSYNC_PERIOD       3000     // three second
-
-#define TSDB_MIN_DB_REPLICA_OPTION      1
-#define TSDB_MAX_DB_REPLICA_OPTION      3
-#define TSDB_DEFAULT_DB_REPLICA_OPTION  1
-
-#define TSDB_MIN_DB_PARTITON_OPTION     0
-#define TSDB_MAX_DB_PARTITON_OPTION     1000
-#define TSDB_DEFAULT_DB_PARTITON_OPTION 4
-
-#define TSDB_MIN_DB_QUORUM_OPTION       1
-#define TSDB_MAX_DB_QUORUM_OPTION       2
-#define TSDB_DEFAULT_DB_QUORUM_OPTION   1
-
 #define TSDB_MAX_JOIN_TABLE_NUM         10
 #define TSDB_MAX_UNION_CLAUSE           5
 
@@ -325,6 +315,11 @@ do { \
 #define TSDB_QUERY_TYPE_NON_TYPE               0x00u     // none type
 #define TSDB_QUERY_TYPE_FREE_RESOURCE          0x01u     // free qhandle at vnode
 
+
+#define TSDB_META_COMPACT_RATIO         0       // disable tsdb meta compact by default
+
+
+
 /*
  * 1. ordinary sub query for select * from super_table
  * 2. all sqlobj generated by createSubqueryObj with this flag
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 117f908faf5dd3f88fe02271ab38a73fab81ed4b..3cf5e52c4498f9c1b5fe1dd53f78d65c7138386a 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -142,13 +142,9 @@ int8_t  tsWAL           = TSDB_DEFAULT_WAL_LEVEL;
 int32_t tsFsyncPeriod   = TSDB_DEFAULT_FSYNC_PERIOD;
 int32_t tsReplications  = TSDB_DEFAULT_DB_REPLICA_OPTION;
 int32_t tsQuorum        = TSDB_DEFAULT_DB_QUORUM_OPTION;
-int16_t tsPartitons     = TSDB_DEFAULT_DB_PARTITON_OPTION;
 int8_t  tsUpdate        = TSDB_DEFAULT_DB_UPDATE_OPTION;
 int8_t  tsCacheLastRow  = TSDB_DEFAULT_CACHE_LAST_ROW;
 int32_t tsMaxVgroupsPerDb  = 0;
-int32_t tsMinTablePerVnode = TSDB_TABLES_STEP;
-int32_t tsMaxTablePerVnode = TSDB_DEFAULT_TABLES;
-int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;
 int32_t tsTsdbMetaCompactRatio = TSDB_META_COMPACT_RATIO;
 
 // tsdb config 
@@ -736,37 +732,6 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  // database configs
-  cfg.option = "maxTablesPerVnode";
-  cfg.ptr = &tsMaxTablePerVnode;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MIN_TABLES;
-  cfg.maxValue = TSDB_MAX_TABLES;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "minTablesPerVnode";
-  cfg.ptr = &tsMinTablePerVnode;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MIN_TABLES;
-  cfg.maxValue = TSDB_MAX_TABLES;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
-  cfg.option = "tableIncStepPerVnode";
-  cfg.ptr = &tsTableIncStepPerVnode;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MIN_TABLES;
-  cfg.maxValue = TSDB_MAX_TABLES;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
   cfg.option = "cache";
   cfg.ptr = &tsCacheBlockSize;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -877,16 +842,6 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  cfg.option = "partitions";
-  cfg.ptr = &tsPartitons;
-  cfg.valType = TAOS_CFG_VTYPE_INT16;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MIN_DB_PARTITON_OPTION;
-  cfg.maxValue = TSDB_MAX_DB_PARTITON_OPTION;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
   cfg.option = "quorum";
   cfg.ptr = &tsQuorum;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -1704,12 +1659,6 @@ int32_t taosCheckGlobalCfg() {
     }
   }
 
-  if (tsMaxTablePerVnode < tsMinTablePerVnode) {
-    uError("maxTablesPerVnode(%d) < minTablesPerVnode(%d), reset to minTablesPerVnode(%d)",
-	   tsMaxTablePerVnode, tsMinTablePerVnode, tsMinTablePerVnode);
-    tsMaxTablePerVnode = tsMinTablePerVnode;
-  }
-
   // todo refactor
   tsVersion = 0;
   for (int ver = 0, i = 0; i < TSDB_VERSION_LEN; ++i) {
diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h
index 24ba2b254f17ec4823bc089c07043d961bfef0f6..1003645143fad5dfcff7a012933d85ef66ea5f91 100644
--- a/source/dnode/mnode/impl/inc/mndDef.h
+++ b/source/dnode/mnode/impl/inc/mndDef.h
@@ -195,7 +195,6 @@ typedef struct SUserObj {
 typedef struct {
   int32_t cacheBlockSize;
   int32_t totalBlocks;
-  int32_t maxTables;
   int32_t daysPerFile;
   int32_t daysToKeep0;
   int32_t daysToKeep1;
@@ -204,14 +203,13 @@ typedef struct {
   int32_t maxRowsPerFileBlock;
   int32_t commitTime;
   int32_t fsyncPeriod;
+  int8_t  walLevel;
   int8_t  precision;
   int8_t  compression;
-  int8_t  walLevel;
   int8_t  replications;
   int8_t  quorum;
   int8_t  update;
   int8_t  cacheLastRow;
-  int8_t  dbType;
 } SDbCfg;
 
 typedef struct SDbObj {
diff --git a/source/dnode/mnode/impl/inc/mndDnode.h b/source/dnode/mnode/impl/inc/mndDnode.h
index a25784e5bb3063def32dadc6008a8adad118a1a3..04ceb2820a25cd5c4a9b75168fbc967ffd467201 100644
--- a/source/dnode/mnode/impl/inc/mndDnode.h
+++ b/source/dnode/mnode/impl/inc/mndDnode.h
@@ -27,6 +27,7 @@ void       mndCleanupDnode(SMnode *pMnode);
 SDnodeObj *mndAcquireDnode(SMnode *pMnode, int32_t dnodeId);
 void       mndReleaseDnode(SMnode *pMnode, SDnodeObj *pDnode);
 SEpSet     mndGetDnodeEpset(SDnodeObj *pDnode);
+int32_t    mndGetDnodeSize(SMnode *pMnode);
 
 #ifdef __cplusplus
 }
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 9b48d121e1db6d40609099d29c9c4ed586da69a8..3e6caba732664337e4c18e2bbce11159b397661c 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -15,11 +15,14 @@
 
 #define _DEFAULT_SOURCE
 #include "mndDb.h"
+#include "mndDnode.h"
 #include "mndMnode.h"
 #include "mndShow.h"
 #include "mndTrans.h"
+#include "mndUser.h"
 
-#define TSDB_DB_VER 1
+#define TSDB_DB_VER_NUM 1
+#define TSDB_DB_RESERVE_SIZE 64
 
 static SSdbRaw *mndDbActionEncode(SDbObj *pDb);
 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw);
@@ -62,7 +65,7 @@ int32_t mndInitDb(SMnode *pMnode) {
 void mndCleanupDb(SMnode *pMnode) {}
 
 static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
-  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER, sizeof(SDbObj));
+  SSdbRaw *pRaw = sdbAllocRaw(SDB_DB, TSDB_DB_VER_NUM, sizeof(SDbObj));
   if (pRaw == NULL) return NULL;
 
   int32_t dataPos = 0;
@@ -73,7 +76,6 @@ static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   SDB_SET_INT64(pRaw, dataPos, pDb->uid)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.cacheBlockSize)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.totalBlocks)
-  SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxTables)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysPerFile)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep0)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.daysToKeep1)
@@ -82,14 +84,14 @@ static SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.maxRowsPerFileBlock)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.commitTime)
   SDB_SET_INT32(pRaw, dataPos, pDb->cfg.fsyncPeriod)
+  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.precision)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.compression)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.walLevel)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.replications)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.quorum)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.update)
   SDB_SET_INT8(pRaw, dataPos, pDb->cfg.cacheLastRow)
-  SDB_SET_INT8(pRaw, dataPos, pDb->cfg.dbType)
+  SDB_SET_RESERVE(pRaw, dataPos, TSDB_DB_RESERVE_SIZE)
   SDB_SET_DATALEN(pRaw, dataPos);
 
   return pRaw;
@@ -99,7 +101,7 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   int8_t sver = 0;
   if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
 
-  if (sver != TSDB_DB_VER) {
+  if (sver != TSDB_DB_VER_NUM) {
     mError("failed to decode db since %s", terrstr());
     terrno = TSDB_CODE_SDB_INVALID_DATA_VER;
     return NULL;
@@ -117,7 +119,6 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT64(pRaw, pRow, dataPos, &pDb->uid)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.cacheBlockSize)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.totalBlocks)
-  SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.maxTables)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysPerFile)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysToKeep0)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.daysToKeep1)
@@ -126,14 +127,14 @@ static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.maxRowsPerFileBlock)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.commitTime)
   SDB_GET_INT32(pRaw, pRow, dataPos, &pDb->cfg.fsyncPeriod)
+  SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.walLevel)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.precision)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.compression)
-  SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.walLevel)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.replications)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.quorum)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.update)
   SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.cacheLastRow)
-  SDB_GET_INT8(pRaw, pRow, dataPos, &pDb->cfg.dbType)
+  SDB_GET_RESERVE(pRaw, pRow, dataPos, TSDB_DB_RESERVE_SIZE)
 
   return pRow;
 }
@@ -164,20 +165,459 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
   sdbRelease(pSdb, pDb);
 }
 
-static int32_t mndProcessCreateDbMsg(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
+  if (pCfg->cacheBlockSize < TSDB_MIN_CACHE_BLOCK_SIZE || pCfg->cacheBlockSize > TSDB_MAX_CACHE_BLOCK_SIZE) {
+    terrno = TSDB_CODE_MND_INVALID_DB_CACHE_SIZE;
+    return -1;
+  }
+
+  if (pCfg->totalBlocks < TSDB_MIN_TOTAL_BLOCKS || pCfg->totalBlocks > TSDB_MAX_TOTAL_BLOCKS) {
+    terrno = TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS;
+    return -1;
+  }
+
+  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) {
+    terrno = TSDB_CODE_MND_INVALID_DB_DAYS;
+    return -1;
+  }
+
+  if (pCfg->daysToKeep0 < pCfg->daysPerFile) {
+    terrno = TSDB_CODE_MND_INVALID_DB_KEEP0;
+    return -1;
+  }
+
+  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP || pCfg->daysToKeep0 > pCfg->daysToKeep1) {
+    terrno = TSDB_CODE_MND_INVALID_DB_KEEP0;
+    return -1;
+  }
+
+  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP || pCfg->daysToKeep1 > pCfg->daysToKeep2) {
+    terrno = TSDB_CODE_MND_INVALID_DB_KEEP1;
+    return -1;
+  }
+
+  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) {
+    terrno = TSDB_CODE_MND_INVALID_DB_KEEP1;
+    return -1;
+  }
+
+  if (pCfg->minRowsPerFileBlock < TSDB_MIN_MIN_ROW_FBLOCK || pCfg->minRowsPerFileBlock > TSDB_MAX_MIN_ROW_FBLOCK) {
+    terrno = TSDB_CODE_MND_INVALID_DB_MIN_ROWS;
+    return -1;
+  }
+
+  if (pCfg->maxRowsPerFileBlock < TSDB_MIN_MAX_ROW_FBLOCK || pCfg->maxRowsPerFileBlock > TSDB_MAX_MAX_ROW_FBLOCK) {
+    terrno = TSDB_CODE_MND_INVALID_DB_MAX_ROWS;
+    return -1;
+  }
+
+  if (pCfg->minRowsPerFileBlock > pCfg->maxRowsPerFileBlock) {
+    terrno = TSDB_CODE_MND_INVALID_DB_MIN_ROWS;
+    return -1;
+  }
+
+  if (pCfg->commitTime < TSDB_MIN_COMMIT_TIME || pCfg->commitTime > TSDB_MAX_COMMIT_TIME) {
+    terrno = TSDB_CODE_MND_INVALID_DB_COMMIT_TIME;
+    return -1;
+  }
+
+  if (pCfg->fsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->fsyncPeriod > TSDB_MAX_FSYNC_PERIOD) {
+    terrno = TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD;
+    return -1;
+  }
+
+  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) {
+    terrno = TSDB_CODE_MND_INVALID_DB_WAL_LEVEL;
+    return -1;
+  }
+
+  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) {
+    terrno = TSDB_CODE_MND_INVALID_DB_PRECISION;
+    return -1;
+  }
+
+  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) {
+    terrno = TSDB_CODE_MND_INVALID_DB_COMP;
+    return -1;
+  }
+
+  if (pCfg->replications < TSDB_MIN_DB_REPLICA_OPTION || pCfg->replications > TSDB_MAX_DB_REPLICA_OPTION) {
+    terrno = TSDB_CODE_MND_INVALID_DB_REPLICA;
+    return -1;
+  }
 
-static int32_t mndProcessAlterDbMsg(SMnodeMsg *pMsg) { return 0; }
+  if (pCfg->replications > mndGetDnodeSize(pMnode)) {
+    terrno = TSDB_CODE_MND_INVALID_DB_REPLICA;
+    return -1;
+  }
+
+  if (pCfg->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCfg->quorum > TSDB_MAX_DB_QUORUM_OPTION) {
+    terrno = TSDB_CODE_MND_INVALID_DB_QUORUM;
+    return -1;
+  }
+
+  if (pCfg->quorum > pCfg->replications) {
+    terrno = TSDB_CODE_MND_INVALID_DB_QUORUM;
+    return -1;
+  }
+
+  if (pCfg->update < TSDB_MIN_DB_UPDATE || pCfg->update > TSDB_MAX_DB_UPDATE) {
+    terrno = TSDB_CODE_MND_INVALID_DB_UPDATE;
+    return -1;
+  }
+
+  if (pCfg->cacheLastRow < TSDB_MIN_DB_CACHE_LAST_ROW || pCfg->cacheLastRow > TSDB_MAX_DB_CACHE_LAST_ROW) {
+    terrno = TSDB_CODE_MND_INVALID_DB_CACHE_LAST;
+    return -1;
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
+  if (pCfg->cacheBlockSize < 0) pCfg->cacheBlockSize = TSDB_DEFAULT_CACHE_BLOCK_SIZE;
+  if (pCfg->totalBlocks < 0) pCfg->totalBlocks = TSDB_DEFAULT_TOTAL_BLOCKS;
+  if (pCfg->daysPerFile < 0) pCfg->daysPerFile = TSDB_DEFAULT_DAYS_PER_FILE;
+  if (pCfg->daysToKeep0 < 0) pCfg->daysToKeep0 = TSDB_DEFAULT_KEEP;
+  if (pCfg->daysToKeep1 < 0) pCfg->daysToKeep1 = TSDB_DEFAULT_KEEP;
+  if (pCfg->daysToKeep2 < 0) pCfg->daysToKeep2 = TSDB_DEFAULT_KEEP;
+  if (pCfg->minRowsPerFileBlock < 0) pCfg->minRowsPerFileBlock = TSDB_DEFAULT_MIN_ROW_FBLOCK;
+  if (pCfg->maxRowsPerFileBlock < 0) pCfg->maxRowsPerFileBlock = TSDB_DEFAULT_MAX_ROW_FBLOCK;
+  if (pCfg->commitTime < 0) pCfg->commitTime = TSDB_DEFAULT_COMMIT_TIME;
+  if (pCfg->fsyncPeriod < 0) pCfg->fsyncPeriod = TSDB_DEFAULT_FSYNC_PERIOD;
+  if (pCfg->walLevel < 0) pCfg->walLevel = TSDB_DEFAULT_WAL_LEVEL;
+  if (pCfg->precision < 0) pCfg->precision = TSDB_DEFAULT_PRECISION;
+  if (pCfg->compression < 0) pCfg->compression = TSDB_DEFAULT_COMP_LEVEL;
+  if (pCfg->replications < 0) pCfg->replications = TSDB_DEFAULT_DB_REPLICA_OPTION;
+  if (pCfg->quorum < 0) pCfg->quorum = TSDB_DEFAULT_DB_QUORUM_OPTION;
+  if (pCfg->update < 0) pCfg->update = TSDB_DEFAULT_DB_UPDATE_OPTION;
+  if (pCfg->cacheLastRow < 0) pCfg->cacheLastRow = TSDB_DEFAULT_CACHE_LAST_ROW;
+}
+
+static int32_t mndCreateDb(SMnode *pMnode, SMnodeMsg *pMsg, SCreateDbMsg *pCreate, char *acct) {
+  SDbObj dbObj = {0};
+  tstrncpy(dbObj.name, pCreate->db, TSDB_FULL_DB_NAME_LEN);
+  tstrncpy(dbObj.acct, acct, TSDB_USER_LEN);
+  dbObj.createdTime = taosGetTimestampMs();
+  dbObj.updateTime = dbObj.createdTime;
+  dbObj.uid = 1234;
+  dbObj.cfg = (SDbCfg){.cacheBlockSize = pCreate->cacheBlockSize,
+                       .totalBlocks = pCreate->totalBlocks,
+                       .daysPerFile = pCreate->daysPerFile,
+                       .daysToKeep0 = pCreate->daysToKeep0,
+                       .daysToKeep1 = pCreate->daysToKeep1,
+                       .daysToKeep2 = pCreate->daysToKeep2,
+                       .minRowsPerFileBlock = pCreate->minRowsPerFileBlock,
+                       .maxRowsPerFileBlock = pCreate->maxRowsPerFileBlock,
+                       .fsyncPeriod = pCreate->fsyncPeriod,
+                       .commitTime = pCreate->commitTime,
+                       .precision = pCreate->precision,
+                       .compression = pCreate->compression,
+                       .walLevel = pCreate->walLevel,
+                       .replications = pCreate->replications,
+                       .quorum = pCreate->quorum,
+                       .update = pCreate->update,
+                       .cacheLastRow = pCreate->cacheLastRow};
+
+  mndSetDefaultDbCfg(&dbObj.cfg);
+
+  if (mndCheckDbCfg(pMnode, &dbObj.cfg) != 0) {
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
+  }
+
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to create db:%s", pTrans->id, pCreate->db);
+
+  SSdbRaw *pRedoRaw = mndDbActionEncode(&dbObj);
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING);
+
+  SSdbRaw *pUndoRaw = mndDbActionEncode(&dbObj);
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
+    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pUndoRaw, SDB_STATUS_DROPPED);
+
+  SSdbRaw *pCommitRaw = mndDbActionEncode(&dbObj);
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+
+  if (mndTransPrepare(pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  mndTransDrop(pTrans);
+  return 0;
+}
+
+static int32_t mndProcessCreateDbMsg(SMnodeMsg *pMsg) {
+  SMnode       *pMnode = pMsg->pMnode;
+  SCreateDbMsg *pCreate = pMsg->rpcMsg.pCont;
+
+  pCreate->cacheBlockSize = htonl(pCreate->cacheBlockSize);
+  pCreate->totalBlocks = htonl(pCreate->totalBlocks);
+  pCreate->daysPerFile = htonl(pCreate->daysPerFile);
+  pCreate->daysToKeep0 = htonl(pCreate->daysToKeep0);
+  pCreate->daysToKeep1 = htonl(pCreate->daysToKeep1);
+  pCreate->daysToKeep2 = htonl(pCreate->daysToKeep2);
+  pCreate->minRowsPerFileBlock = htonl(pCreate->minRowsPerFileBlock);
+  pCreate->maxRowsPerFileBlock = htonl(pCreate->maxRowsPerFileBlock);
+  pCreate->commitTime = htonl(pCreate->commitTime);
+  pCreate->fsyncPeriod = htonl(pCreate->fsyncPeriod);
+
+  mDebug("db:%s, start to create", pCreate->db);
+
+  SDbObj *pDb = mndAcquireDb(pMnode, pCreate->db);
+  if (pDb != NULL) {
+    sdbRelease(pMnode->pSdb, pDb);
+    if (pCreate->ignoreExist) {
+      mDebug("db:%s, already exist, ignore exist is set", pCreate->db);
+      return 0;
+    } else {
+      terrno = TSDB_CODE_MND_DB_ALREADY_EXIST;
+      mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+      return -1;
+    }
+  }
+
+  SUserObj *pOperUser = mndAcquireUser(pMnode, pMsg->user);
+  if (pOperUser == NULL) {
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
+  }
 
-static int32_t mndProcessDropDbMsg(SMnodeMsg *pMsg) { return 0; }
+  int32_t code = mndCreateDb(pMnode, pMsg, pCreate, pOperUser->acct);
+  mndReleaseUser(pMnode, pOperUser);
+
+  if (code != 0) {
+    terrno = code;
+    mError("db:%s, failed to create since %s", pCreate->db, terrstr());
+    return -1;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
+
+static int32_t mnodeSetDbCfgFromAlterDbMsg(SDbObj *pDb, SAlterDbMsg *pAlter) {
+  bool changed = false;
+
+  if (pAlter->totalBlocks >= 0 && pAlter->totalBlocks != pDb->cfg.totalBlocks) {
+    pDb->cfg.totalBlocks = pAlter->totalBlocks;
+    changed = true;
+  }
+
+  if (pAlter->daysToKeep0 >= 0 && pAlter->daysToKeep0 != pDb->cfg.daysToKeep0) {
+    pDb->cfg.daysToKeep0 = pAlter->daysToKeep0;
+    changed = true;
+  }
+
+  if (pAlter->daysToKeep1 >= 0 && pAlter->daysToKeep1 != pDb->cfg.daysToKeep1) {
+    pDb->cfg.daysToKeep1 = pAlter->daysToKeep1;
+    changed = true;
+  }
+
+  if (pAlter->daysToKeep2 >= 0 && pAlter->daysToKeep2 != pDb->cfg.daysToKeep2) {
+    pDb->cfg.daysToKeep2 = pAlter->daysToKeep2;
+    changed = true;
+  }
+
+  if (pAlter->fsyncPeriod >= 0 && pAlter->fsyncPeriod != pDb->cfg.fsyncPeriod) {
+    pDb->cfg.fsyncPeriod = pAlter->fsyncPeriod;
+    changed = true;
+  }
+
+  if (pAlter->walLevel >= 0 && pAlter->walLevel != pDb->cfg.walLevel) {
+    pDb->cfg.walLevel = pAlter->walLevel;
+    changed = true;
+  }
+
+  if (pAlter->quorum >= 0 && pAlter->quorum != pDb->cfg.quorum) {
+    pDb->cfg.quorum = pAlter->quorum;
+    changed = true;
+  }
+
+  if (pAlter->cacheLastRow >= 0 && pAlter->cacheLastRow != pDb->cfg.cacheLastRow) {
+    pDb->cfg.cacheLastRow = pAlter->cacheLastRow;
+    changed = true;
+  }
+
+  if (!changed) {
+    terrno = TSDB_CODE_MND_DB_OPTION_UNCHANGED;
+    return -1;
+  }
+
+  return 0;
+}
+
+static int32_t mndUpdateDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pOldDb, SDbObj *pNewDb) {
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("db:%s, failed to update since %s", pOldDb->name, terrstr());
+    return terrno;
+  }
+
+  mDebug("trans:%d, used to update db:%s", pTrans->id, pOldDb->name);
+
+  SSdbRaw *pRedoRaw = mndDbActionEncode(pNewDb);
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
+
+  SSdbRaw *pUndoRaw = mndDbActionEncode(pOldDb);
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
+    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
+
+  if (mndTransPrepare(pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  mndTransDrop(pTrans);
+  return 0;
+}
+
+static int32_t mndProcessAlterDbMsg(SMnodeMsg *pMsg) {
+  SMnode      *pMnode = pMsg->pMnode;
+  SAlterDbMsg *pAlter = pMsg->rpcMsg.pCont;
+  pAlter->totalBlocks = htonl(pAlter->totalBlocks);
+  pAlter->daysToKeep0 = htonl(pAlter->daysToKeep0);
+  pAlter->daysToKeep1 = htonl(pAlter->daysToKeep1);
+  pAlter->daysToKeep2 = htonl(pAlter->daysToKeep2);
+  pAlter->fsyncPeriod = htonl(pAlter->fsyncPeriod);
+
+  mDebug("db:%s, start to alter", pAlter->db);
+
+  SDbObj *pDb = mndAcquireDb(pMnode, pAlter->db);
+  if (pDb == NULL) {
+    mError("db:%s, failed to alter since %s", pAlter->db, terrstr());
+    return TSDB_CODE_MND_DB_NOT_EXIST;
+  }
+
+  SDbObj dbObj = {0};
+  memcpy(&dbObj, pDb, sizeof(SDbObj));
+
+  int32_t code = mnodeSetDbCfgFromAlterDbMsg(&dbObj, pAlter);
+  if (code != 0) {
+    mndReleaseDb(pMnode, pDb);
+    mError("db:%s, failed to alter since %s", pAlter->db, tstrerror(code));
+    return code;
+  }
+
+  code = mndUpdateDb(pMnode, pMsg, pDb, &dbObj);
+  mndReleaseDb(pMnode, pDb);
+
+  if (code != 0) {
+    mError("db:%s, failed to alter since %s", pAlter->db, tstrerror(code));
+    return code;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
+
+static int32_t mndDropDb(SMnode *pMnode, SMnodeMsg *pMsg, SDbObj *pDb) {
+  STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, pMsg->rpcMsg.handle);
+  if (pTrans == NULL) {
+    mError("db:%s, failed to drop since %s", pDb->name, terrstr());
+    return -1;
+  }
+  mDebug("trans:%d, used to drop db:%s", pTrans->id, pDb->name);
+
+  SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);
+  if (pRedoRaw == NULL || mndTransAppendRedolog(pTrans, pRedoRaw) != 0) {
+    mError("trans:%d, failed to append redo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING);
+
+  SSdbRaw *pUndoRaw = mndDbActionEncode(pDb);
+  if (pUndoRaw == NULL || mndTransAppendUndolog(pTrans, pUndoRaw) != 0) {
+    mError("trans:%d, failed to append undo log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pUndoRaw, SDB_STATUS_READY);
+
+  SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);
+  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+  sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
+
+  if (mndTransPrepare(pTrans) != 0) {
+    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mndTransDrop(pTrans);
+    return -1;
+  }
+
+  mndTransDrop(pTrans);
+  return 0;
+}
+
+static int32_t mndProcessDropDbMsg(SMnodeMsg *pMsg) {
+  SMnode     *pMnode = pMsg->pMnode;
+  SDropDbMsg *pDrop = pMsg->rpcMsg.pCont;
+
+  mDebug("db:%s, start to drop", pDrop->db);
+
+  SDbObj *pDb = mndAcquireDb(pMnode, pDrop->db);
+  if (pDb == NULL) {
+    if (pDrop->ignoreNotExists) {
+      mDebug("db:%s, not exist, ignore not exist is set", pDrop->db);
+      return TSDB_CODE_SUCCESS;
+    } else {
+      terrno = TSDB_CODE_MND_DB_NOT_EXIST;
+      mError("db:%s, failed to drop since %s", pDrop->db, terrstr());
+      return -1;
+    }
+  }
+
+  int32_t code = mndDropDb(pMnode, pMsg, pDb);
+  mndReleaseDb(pMnode, pDb);
+
+  if (code != 0) {
+    terrno = code;
+    mError("db:%s, failed to drop since %s", pDrop->db, terrstr());
+    return code;
+  }
+
+  return TSDB_CODE_MND_ACTION_IN_PROGRESS;
+}
 
 static int32_t mndProcessUseDbMsg(SMnodeMsg *pMsg) {
   SMnode    *pMnode = pMsg->pMnode;
   SUseDbMsg *pUse = pMsg->rpcMsg.pCont;
 
-  strncpy(pMsg->db, pUse->db, TSDB_FULL_DB_NAME_LEN);
-
   SDbObj *pDb = mndAcquireDb(pMnode, pMsg->db);
   if (pDb != NULL) {
+    strncpy(pMsg->db, pUse->db, TSDB_FULL_DB_NAME_LEN);
     mndReleaseDb(pMnode, pDb);
     return 0;
   } else {
@@ -186,9 +626,33 @@ static int32_t mndProcessUseDbMsg(SMnodeMsg *pMsg) {
   }
 }
 
-static int32_t mndProcessSyncDbMsg(SMnodeMsg *pMsg) { return 0; }
+static int32_t mndProcessSyncDbMsg(SMnodeMsg *pMsg) {
+  SMnode     *pMnode = pMsg->pMnode;
+  SSyncDbMsg *pSync = pMsg->rpcMsg.pCont;
 
-static int32_t mndProcessCompactDbMsg(SMnodeMsg *pMsg) { return 0; }
+  SDbObj *pDb = mndAcquireDb(pMnode, pMsg->db);
+  if (pDb == NULL) {
+    mError("db:%s, failed to process sync db msg since %s", pMsg->db, terrstr());
+    return -1;
+  } else {
+    mndReleaseDb(pMnode, pDb);
+    return 0;
+  }
+}
+
+static int32_t mndProcessCompactDbMsg(SMnodeMsg *pMsg) {
+  SMnode        *pMnode = pMsg->pMnode;
+  SCompactDbMsg *pCompact = pMsg->rpcMsg.pCont;
+
+  SDbObj *pDb = mndAcquireDb(pMnode, pMsg->db);
+  if (pDb == NULL) {
+    mError("db:%s, failed to process compact db msg since %s", pMsg->db, terrstr());
+    return -1;
+  } else {
+    mndReleaseDb(pMnode, pDb);
+    return 0;
+  }
+}
 
 static int32_t mndGetDbMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *pMeta) {
   SMnode *pMnode = pMsg->pMnode;
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index c34d12c6e2a39e42ab3f4fb9a15935cda679a74e..b614209e7627835e95d39a9e7e4a587f77caf1dd 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -216,7 +216,7 @@ static SDnodeObj *mndAcquireDnodeByEp(SMnode *pMnode, char *pEpStr) {
   return NULL;
 }
 
-static int32_t mndGetDnodeSize(SMnode *pMnode) {
+int32_t mndGetDnodeSize(SMnode *pMnode) {
   SSdb *pSdb = pMnode->pSdb;
   return sdbGetSize(pSdb, SDB_DNODE);
 }
diff --git a/source/dnode/vnode/impl/CMakeLists.txt b/source/dnode/vnode/impl/CMakeLists.txt
index 040b02d2b6633faaf711f7ceff2aa02adb499215..d6d267c4d441483c92049e5bdf1549ac4459b718 100644
--- a/source/dnode/vnode/impl/CMakeLists.txt
+++ b/source/dnode/vnode/impl/CMakeLists.txt
@@ -18,6 +18,6 @@ target_link_libraries(
 )
 
 # test
-if(${BUILD_TEST})
-    add_subdirectory(test)
-endif(${BUILD_TEST})
\ No newline at end of file
+#if(${BUILD_TEST})
+#    add_subdirectory(test)
+#endif(${BUILD_TEST})
\ No newline at end of file
diff --git a/source/libs/parser/src/astGenerator.c b/source/libs/parser/src/astGenerator.c
index f32848655635ddfd259b913d85b59801ff1e68f7..3b7d1cbc2941e5a99468d483714cdd27351c8069 100644
--- a/source/libs/parser/src/astGenerator.c
+++ b/source/libs/parser/src/astGenerator.c
@@ -972,13 +972,6 @@ void setDefaultCreateDbOption(SCreateDbInfo *pDBInfo) {
   memset(&pDBInfo->precision, 0, sizeof(SToken));
 }
 
-void setDefaultCreateTopicOption(SCreateDbInfo *pDBInfo) {
-  setDefaultCreateDbOption(pDBInfo);
-
-  pDBInfo->dbType = TSDB_DB_TYPE_TOPIC;
-  pDBInfo->partitions = TSDB_DEFAULT_DB_PARTITON_OPTION;
-}
-
 // prefix show db.tables;
 void tSetDbName(SToken *pCpxName, SToken *pDb) {
   pCpxName->type = pDb->type;
diff --git a/source/util/src/terror.c b/source/util/src/terror.c
index c8904d624881a36e5c5d393546eba4ca649b8f15..5110c8ba226d09d806d91e25be2ee069e8a8a171 100644
--- a/source/util/src/terror.c
+++ b/source/util/src/terror.c
@@ -223,21 +223,29 @@ TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TAG_LENGTH,        "invalid tag length")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_COLUMN_LENGTH,     "invalid column length")
 
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_SELECTED,          "Database not specified or available")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_NOT_EXIST,             "Database not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_ALREADY_EXIST,         "Database already exists")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION,        "Invalid database options")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB,               "Invalid database name")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_MONITOR_DB_FORBIDDEN,     "Cannot delete monitor database")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION,        "Invalid database options")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_CACHE_SIZE,    "Invalid database cache block size option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_TOTAL_BLOCKS,  "Invalid database total blocks option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_DAYS,          "Invalid database days option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP0,         "Invalid database keep0 option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP1,         "Invalid database keep1 option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_KEEP2,         "Invalid database keep2 option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_MIN_ROWS,      "Invalid database min rows option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_MAX_ROWS,      "Invalid database max rows option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_COMMIT_TIME,   "Invalid database commit time option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_FSYNC_PERIOD,  "Invalid database fsync periodoptions")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_WAL_LEVEL,     "Invalid database wal level option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_PRECISION,     "Invalid database precisin option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_COMP,          "Invalid database compression option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_REPLICA,       "Invalid database replication option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_QUORUM,        "Invalid database quorum option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_UPDATE,        "Invalid database update option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_CACHE_LAST,    "Invalid database cache last option")
+TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_OPTION_UNCHANGED,      "Database options not changed")
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOO_MANY_DATABASES,       "Too many databases for account")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_DB_IN_DROPPING,           "Database not available")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_VGROUP_NOT_READY,         "Database unsynced")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION_DAYS,   "Invalid database option: days out of range")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_DB_OPTION_KEEP,   "Invalid database option: keep2 >= keep1 >= keep0 >= days")
-
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC,            "Invalid topic name")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC_OPTION,     "Invalid topic option")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_INVALID_TOPIC_PARTITONS,  "Invalid topic partitons num, valid range: [1, 1000]")
-TAOS_DEFINE_ERROR(TSDB_CODE_MND_TOPIC_ALREADY_EXIST,      "Topic already exists")
 
 // dnode
 TAOS_DEFINE_ERROR(TSDB_CODE_DND_ACTION_IN_PROGRESS,       "Action in progress")