diff --git a/README.MD b/README.MD
index c1f97dd..4fb83ca 100644
--- a/README.MD
+++ b/README.MD
@@ -20,9 +20,9 @@ STVM（truck of Virtual memory table）是一个开源的使用ANSI C语言编
 *  多机集群无法使用事务。
 *  数据无法持久化(宕机情况)。
 *  索引长度限制（默认64字节），修改需编译项目。
-*  启动后不能修改表字段
+*  启动后不能修改表字段，但可以修改字段别名
 
-建议使用场景：***数据库缓存、数据缓存***
+建议使用场景：***数据库缓存、数据缓存、事件驱动***
 
 不定时更新 https://my.oschina.net/deffpuzzl/blog/1627626  
 
diff --git a/bin/msql b/bin/msql
index 2721f23..ec3acc0 100755
--- a/bin/msql
+++ b/bin/msql
@@ -1,2 +1,2 @@
 #!/bin/bash
-stvm SQL --showmode=row --showsize=5
+stvm SQL --showmode=row --showsize=8
diff --git a/demo/create_queue.c b/demo/create_queue.c
index d091324..6d068a2 100644
--- a/demo/create_queue.c
+++ b/demo/create_queue.c
@@ -32,7 +32,7 @@ int   main(int argc, char *argv[])
     SATvm   *pstSavm = (SATvm *)pGetSATvm();
 
 //    if(RC_SUCC != lCreateQueue(pstSavm, QUEUE_USER_INFO, 1000000, sizeof(szMsg), ""))
-    if(RC_SUCC != lTableQueue(pstSavm, QUEUE_USER_INFO, 50000, lQueueUserInfo))
+    if(RC_SUCC != lTableQueue(pstSavm, QUEUE_USER_INFO, 30, lQueueUserInfo))
     {
 	    fprintf(stderr, "create queue %d failed, err: %s\n", QUEUE_USER_INFO, sGetTError(pstSavm->m_lErrno));
         return RC_FAIL;
diff --git a/demo/insert.c b/demo/insert.c
index 4f96c1b..914b502 100644
--- a/demo/insert.c
+++ b/demo/insert.c
@@ -5,7 +5,7 @@
 
 typedef struct  __TBL_USER_INFO
 {
-   long    acct_id;
+   llong   acct_id;
    char    user_no[21];
    char    user_type[2];
    char    user_nm[81];
@@ -27,8 +27,8 @@ int   main(int argc, char *argv[])
     }
  
     conditinit(pstSavm, stUser, TBL_USER_INFO);          // 绑定变量
-//  stUser.acct_id = time(NULL);                         // 对结构体赋值
-    strcpy(stUser.user_no,    "20180224");               // 对结构体赋值
+//  stUser.acct_id = 7;                                  // 对结构体赋值
+    strcpy(stUser.user_no,    "20180223");               // 对结构体赋值
     strcpy(stUser.user_type,  "1");                      // 对结构体赋值
     strcpy(stUser.user_nm,    "Savens Liu");             // 对结构体赋值
     strcpy(stUser.user_addr,  "China");                  // 对结构体赋值
diff --git a/include/tvm.h b/include/tvm.h
index 0315421..10e3b91 100644
--- a/include/tvm.h
+++ b/include/tvm.h
@@ -312,6 +312,7 @@ typedef long                 CREATE;
 #define MQUE_CRTE_BIG                       99          // created queue is too big
 #define NOT_SUPPT_OPT                      100          // queue does not support this operation
 #define SERV_NOT_CONN                      101          // not connect server
+#define PART_AR_EXIST                      102          // partion already exist
 
 /*************************************************************************************************
      创建表宏函数
diff --git a/src/queue.c b/src/queue.c
index 2ee771d..d1132b7 100644
--- a/src/queue.c
+++ b/src/queue.c
@@ -206,7 +206,7 @@ long    _lPops(SATvm *pstSavm, void *pvAddr, size_t lExpect, Timesp *tm, size_t
             void **ppsvOut)
 {
     Timesp  tms;
-    int     nPos;
+    int     nPos, i = 0;
     SHTruck *ps = NULL;
     extern  int errno;
     TblDef  *pv = (TblDef *)pvAddr;
@@ -219,7 +219,7 @@ long    _lPops(SATvm *pstSavm, void *pvAddr, size_t lExpect, Timesp *tm, size_t
 
     for (*plOut = 0, clock_gettime(CLOCK_REALTIME, &tms); *plOut < lExpect; )
     {
-		if(!bIsTimeOut(tm, &tms)) 
+        if(!bIsTimeOut(tm, &tms)) 
         {
             pstSavm->m_lEffect = *plOut;
             if(0 == pstSavm->m_lEffect)
@@ -264,6 +264,7 @@ long    _lPops(SATvm *pstSavm, void *pvAddr, size_t lExpect, Timesp *tm, size_t
             continue;
         }
     
+retrys:
         /* at least cost one vaild */
         if(pv->m_lMaxRow > (nPos = __sync_add_and_fetch(&pv->m_lListOfs, 1)))
             ;
@@ -273,10 +274,15 @@ long    _lPops(SATvm *pstSavm, void *pvAddr, size_t lExpect, Timesp *tm, size_t
         ps = (PSHTruck)pGetNode(pvAddr, pv->m_lData + pv->m_lTruck * nPos);
         if(IS_TRUCK_NULL(ps))
         {
-            *plOut = 0;
-            TFree(*ppsvOut);
-            pstSavm->m_lErrno = SVR_EXCEPTION;
-            return RC_FAIL;
+            if((++ i) > pv->m_lMaxRow)
+            {
+                *plOut = 0;
+                TFree(*ppsvOut);
+                pstSavm->m_lErrno = SVR_EXCEPTION;
+                return RC_FAIL;
+            }
+
+            goto retrys;
         }
 
         memcpy(*ppsvOut + (*plOut) * pv->m_lReSize, ps->m_pvData, pv->m_lReSize);
diff --git a/src/stvm.c b/src/stvm.c
index 9d03d18..b3b975f 100644
--- a/src/stvm.c
+++ b/src/stvm.c
@@ -288,12 +288,12 @@ int   sizecn(TblKey *pstKey, long lfld)
     parameters：
         s                          --string
         len                        --strlen length
-        pstTde                     --Table define
+        ps                         --Table define
     return：
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    lAnalysHead(char *s, long len, TblDef *pstTde)
+long    lAnalysHead(char *s, long len, TblDef *ps)
 {
     long    i, n;
     char    szTemp[512], szHead[512], szTar[64], *p = NULL;
@@ -324,34 +324,34 @@ long    lAnalysHead(char *s, long len, TblDef *pstTde)
         sltrim(szTar);
         if(!strcasecmp(szTar, "TABLE"))
         {
-            pstTde->m_table = atol(sfieldvalue(szTemp + 4, "=", 2));
-            if(pstTde->m_table < 5)
+            ps->m_table = atol(sfieldvalue(szTemp + 4, "=", 2));
+            if(ps->m_table < 5)
             {
                 fprintf(stderr, "definition table error\n");
                 return RC_FAIL;
             }
         }
         else if(!strcasecmp(szTar, "TABLESPACE"))
-            pstTde->m_lMaxRow = atol(sfieldvalue(szTemp + 4, "=", 2));
+            ps->m_lMaxRow = atol(sfieldvalue(szTemp + 4, "=", 2));
         else
         {
             fprintf(stderr, "Unrecognized command\n*%s\n", szTemp);
             return RC_FAIL;
         }
     }
-    if(pstTde->m_table < 5)
+    if(ps->m_table < 5)
     {
         fprintf(stderr, "table not define\n");
         return RC_FAIL;
     }
 
-    if(pstTde->m_lMaxRow <= 0)
+    if(ps->m_lMaxRow <= 0)
     {
         fprintf(stderr, "table size node define\n");
         return RC_FAIL;
     }
 
-    strcpy(pstTde->m_szPart, sGetNode());
+    strcpy(ps->m_szPart, sGetNode());
 
     return RC_SUCC;
 }
@@ -359,21 +359,21 @@ long    lAnalysHead(char *s, long len, TblDef *pstTde)
 /*************************************************************************************************
     description：alias table field name
     parameters：
-        pstTde                     --Table define
+        ps                         --Table define
         pszField                   --string
         pszAlias                   --string
     return：
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    lTableAliase(TblDef *pstTde, char *pszField, char *pszAlias)
+long    lTableAliase(TblDef *ps, char *pszField, char *pszAlias)
 {
     long    i = 0;
     TblKey  *pv = NULL;
 
-    for(i = 0; i < pstTde->m_lIdxNum; i ++)
+    for(i = 0; i < ps->m_lIdxNum; i ++)
     {
-        pv = &pstTde->m_stKey[i];
+        pv = &ps->m_stKey[i];
         if(strcmp(pv->m_szField, pszField))
             continue;
 
@@ -388,7 +388,6 @@ long    lTableAliase(TblDef *pstTde, char *pszField, char *pszAlias)
 /*************************************************************************************************
     description：alias the table field name
     parameters：
-        pstTde                     --Table define
         pszField                   --string
         pszAlias                   --string
     return：
@@ -435,12 +434,12 @@ long    _lParseAlias(SATvm *pstSavm, char *pszTable, char *pszField, char *pszAl
     parameters：
         s                          --string
         len                        --strlen length
-        pstTde                     --Table define
+        ps                         --Table define
     return：
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    lAnalysTable(char *s, long len, TblDef *pstTde)
+long    lAnalysTable(char *s, long len, TblDef *ps)
 {
     long    i, n, k;
     TblKey  *pv = NULL;
@@ -455,7 +454,7 @@ long    lAnalysTable(char *s, long len, TblDef *pstTde)
 
     strncpy(szField, s, len);
     strimabout(szField, "(", ")");
-    for(i = 0, n = lgetstrnum(szField, "\n"), pstTde->m_lIdxNum = 0; i < n; i ++)
+    for(i = 0, n = lgetstrnum(szField, "\n"), ps->m_lIdxNum = 0; i < n; i ++)
     {
         memset(szTemp, 0, sizeof(szTemp));
         strncpy(szTemp, sfieldvalue(szField, "\n", i + 1), sizeof(szTemp));
@@ -466,7 +465,7 @@ long    lAnalysTable(char *s, long len, TblDef *pstTde)
         if('#' == szTemp[0] || !strncmp(szTemp, "--", 2) || !strlen(szTemp))
             continue;
 
-        pv = &pstTde->m_stKey[pstTde->m_lIdxNum];
+        pv = &ps->m_stKey[ps->m_lIdxNum];
         strncpy(pv->m_szField, sfieldvalue(szTemp, " ", 1), MAX_FIELD_LEN);
         strcpy(pv->m_szAlias, pv->m_szField);
         if(!strlen(pv->m_szField))
@@ -535,7 +534,7 @@ long    lAnalysTable(char *s, long len, TblDef *pstTde)
             return RC_FAIL;
         }
 
-        pstTde->m_lIdxNum ++;
+        ps->m_lIdxNum ++;
     }
 
     return RC_SUCC;
@@ -545,13 +544,13 @@ long    lAnalysTable(char *s, long len, TblDef *pstTde)
     description：creates the table index 
     parameters：
         s                          --string
-        pstTde                     --Table define
+        ps                         --Table define
         em                         --index type
     return：
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    lIndexField(char *s, TblDef *pstTde, Uenum em)
+long    lIndexField(char *s, TblDef *ps, Uenum em)
 {
     long    i, n;
     TblKey  *pstKey = NULL;
@@ -560,68 +559,68 @@ long    lIndexField(char *s, TblDef *pstTde, Uenum em)
     n = lfieldnum(s, ",");
     if(UNQIUE == em)
     {
-        for(i = 0, pstTde->m_lIType |= UNQIUE, pstTde->m_lIdxUp = 0; i < n; i ++)
+        for(i = 0, ps->m_lIType |= UNQIUE, ps->m_lIdxUp = 0; i < n; i ++)
         {
             memset(szField, 0, MAX_FIELD_LEN);
             strncpy(szField, sfieldvalue(s, ",", i + 1), MAX_FIELD_LEN);
             strimcrlf(szField);
             strimall(szField);
-            if(NULL == (pstKey = pFindField(pstTde->m_stKey, pstTde->m_lIdxNum, szField)))
+            if(NULL == (pstKey = pFindField(ps->m_stKey, ps->m_lIdxNum, szField)))
                 return RC_FAIL;
 
-            strcpy(pstTde->m_stIdxUp[pstTde->m_lIdxUp].m_szField, szField);
-            pstTde->m_stIdxUp[pstTde->m_lIdxUp].m_lFrom = pstKey->m_lFrom;
-            pstTde->m_stIdxUp[pstTde->m_lIdxUp].m_lLen  = pstKey->m_lLen;
-            pstTde->m_stIdxUp[pstTde->m_lIdxUp].m_lAttr = pstKey->m_lAttr;
-            pstTde->m_lIdxLen += pstKey->m_lLen;
-            pstTde->m_lIdxUp ++;
+            strcpy(ps->m_stIdxUp[ps->m_lIdxUp].m_szField, szField);
+            ps->m_stIdxUp[ps->m_lIdxUp].m_lFrom = pstKey->m_lFrom;
+            ps->m_stIdxUp[ps->m_lIdxUp].m_lLen  = pstKey->m_lLen;
+            ps->m_stIdxUp[ps->m_lIdxUp].m_lAttr = pstKey->m_lAttr;
+            ps->m_lIdxLen += pstKey->m_lLen;
+            ps->m_lIdxUp ++;
         }
-        if(0 == pstTde->m_lIdxUp)
+        if(0 == ps->m_lIdxUp)
             return RC_FAIL;
         return RC_SUCC;
     }
     else if(NORMAL == em)
     {
-        for(i = 0, pstTde->m_lIType |= NORMAL, pstTde->m_lGrpUp = 0; i < n; i ++)
+        for(i = 0, ps->m_lIType |= NORMAL, ps->m_lGrpUp = 0; i < n; i ++)
         {
             memset(szField, 0, MAX_FIELD_LEN);
             strncpy(szField, sfieldvalue(s, ",", i + 1), MAX_FIELD_LEN);
             strimcrlf(szField);
             strimall(szField);
-            if(NULL == (pstKey = pFindField(pstTde->m_stKey, pstTde->m_lIdxNum, szField)))
+            if(NULL == (pstKey = pFindField(ps->m_stKey, ps->m_lIdxNum, szField)))
                 return RC_FAIL;
 
-            strcpy(pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_szField, szField);
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lFrom = pstKey->m_lFrom;
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lLen  = pstKey->m_lLen;
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lAttr = pstKey->m_lAttr;
-            pstTde->m_lGrpLen += pstKey->m_lLen;
-            pstTde->m_lGrpUp ++;
+            strcpy(ps->m_stGrpUp[ps->m_lGrpUp].m_szField, szField);
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lFrom = pstKey->m_lFrom;
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lLen  = pstKey->m_lLen;
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lAttr = pstKey->m_lAttr;
+            ps->m_lGrpLen += pstKey->m_lLen;
+            ps->m_lGrpUp ++;
         }
 
-        if(0 == pstTde->m_lGrpUp)
+        if(0 == ps->m_lGrpUp)
             return RC_FAIL;
         return RC_SUCC;
     }
     else if(HASHID == em)
     {
-        for(i = 0, pstTde->m_lIType |= HASHID, pstTde->m_lGrpUp = 0; i < n; i ++)
+        for(i = 0, ps->m_lIType |= HASHID, ps->m_lGrpUp = 0; i < n; i ++)
         {
             memset(szField, 0, MAX_FIELD_LEN);
             strncpy(szField, sfieldvalue(s, ",", i + 1), MAX_FIELD_LEN);
             strimcrlf(szField);
             strimall(szField);
-            if(NULL == (pstKey = pFindField(pstTde->m_stKey, pstTde->m_lIdxNum, szField)))
+            if(NULL == (pstKey = pFindField(ps->m_stKey, ps->m_lIdxNum, szField)))
                 return RC_FAIL;
-            strcpy(pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_szField, szField);
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lFrom = pstKey->m_lFrom;
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lLen  = pstKey->m_lLen;
-            pstTde->m_stGrpUp[pstTde->m_lGrpUp].m_lAttr = pstKey->m_lAttr;
-            pstTde->m_lGrpLen += pstKey->m_lLen;
-            pstTde->m_lGrpUp ++;
+            strcpy(ps->m_stGrpUp[ps->m_lGrpUp].m_szField, szField);
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lFrom = pstKey->m_lFrom;
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lLen  = pstKey->m_lLen;
+            ps->m_stGrpUp[ps->m_lGrpUp].m_lAttr = pstKey->m_lAttr;
+            ps->m_lGrpLen += pstKey->m_lLen;
+            ps->m_lGrpUp ++;
         }
 
-        if(0 == pstTde->m_lGrpUp)
+        if(0 == ps->m_lGrpUp)
             return RC_FAIL;
         return RC_SUCC;
     }
@@ -633,13 +632,13 @@ long    lIndexField(char *s, TblDef *pstTde, Uenum em)
     description：analysis of the header index
     parameters：
         s                          --string
-        pstTde                     --Table define
+        ps                         --Table define
         em                         --index type
     return：
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    lAnalysIndex(char *s, long len, TblDef *pstTde)
+long    lAnalysIndex(char *s, long len, TblDef *ps)
 {
     long    i, n, k, lRet;
     char    szIndex[1024], szTemp[256], *p = NULL;
@@ -657,7 +656,7 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
 
     strncpy(szIndex, s, len);
     strcat(szIndex, "\n");
-    for(i = 0, k = 0, n = lgetstrnum(szIndex, "\n"), pstTde->m_lIType = 0; i < n; i ++)
+    for(i = 0, k = 0, n = lgetstrnum(szIndex, "\n"), ps->m_lIType = 0; i < n; i ++)
     {
         memset(szTemp, 0, sizeof(szTemp));
         strncpy(szTemp, sfieldvalue(szIndex, "\n", i + 1), sizeof(szTemp));
@@ -678,7 +677,7 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
             }
 
             k |= UNQIUE;
-            lRet = lIndexField(p, pstTde, UNQIUE);
+            lRet = lIndexField(p, ps, UNQIUE);
         }
         else if(p = strcasestr(szTemp, "create index"))
         {
@@ -690,7 +689,7 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
             }
 
             k |= NORMAL;
-            lRet = lIndexField(p, pstTde, NORMAL);
+            lRet = lIndexField(p, ps, NORMAL);
         }
         else if(p = strcasestr(szTemp, "create hash"))
         {
@@ -702,7 +701,7 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
             }
 
             k |= NORMAL;
-            lRet = lIndexField(p, pstTde, HASHID);
+            lRet = lIndexField(p, ps, HASHID);
         }
         else if(p = strcasestr(szTemp, "comment on "))
         {
@@ -735,9 +734,9 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
                 p = szComm + strlen(szTable) + 1;
                 strimabout(p, "'", "'");
                 strimabout(p, "\"", "\"");
-                if(!strcmp(szTable, pstTde->m_szTable)) // current table
+                if(!strcmp(szTable, ps->m_szTable)) // current table
                 {
-                    if(RC_SUCC != (lRet = lTableAliase(pstTde, p, szAlias)))
+                    if(RC_SUCC != (lRet = lTableAliase(ps, p, szAlias)))
                     {
                         fprintf(stderr, "table %s field:%s not exist\n", szTable, p);
                         return RC_FAIL;
@@ -755,7 +754,7 @@ long    lAnalysIndex(char *s, long len, TblDef *pstTde)
             }
             else
             {
-                if(RC_SUCC != (lRet = lTableAliase(pstTde, szComm, szAlias)))
+                if(RC_SUCC != (lRet = lTableAliase(ps, szComm, szAlias)))
                 {
                     fprintf(stderr, "table %s field:%s not exist\n", szTable, szComm);
                     return RC_FAIL;
@@ -814,11 +813,11 @@ char*   sGetTabName(char *pszTable)
 /*************************************************************************************************
     description：creates the table struck 
     parameters：
-        pstTde                     --Table define
+        ps                         --Table define
         em                         --index type
     return：
  *************************************************************************************************/
-void    vCreateStruck(TblDef *pstTde, bool bf)
+void    vCreateStruck(TblDef *ps, bool bf)
 {
     long    i;
     TblKey  *pv = NULL;
@@ -826,14 +825,14 @@ void    vCreateStruck(TblDef *pstTde, bool bf)
     fprintf(stdout, "\n#Table definition\n");
     if(bf)
     {
-        fprintf(stdout, "\nset TABLE=%d\n", pstTde->m_table);
-        fprintf(stdout, "set TABLESPACE=%ld\n\n", pstTde->m_lMaxRow);
+        fprintf(stdout, "\nset TABLE=%d\n", ps->m_table);
+        fprintf(stdout, "set TABLESPACE=%ld\n\n", ps->m_lMaxRow);
     }
 
-    fprintf(stdout, "typedef struct __%s\n{\n", supper(pstTde->m_szTable));
-    for(i = 0; i < pstTde->m_lIdxNum; i ++)
+    fprintf(stdout, "typedef struct __%s\n{\n", supper(ps->m_szTable));
+    for(i = 0; i < ps->m_lIdxNum; i ++)
     {
-        pv = &pstTde->m_stKey[i];
+        pv = &ps->m_stKey[i];
         if(FIELD_CHAR == pv->m_lAttr)
         {
             if(1 == pv->m_lLen)
@@ -877,42 +876,42 @@ void    vCreateStruck(TblDef *pstTde, bool bf)
         }
     }
 
-    fprintf(stdout, "}%s;\n", sGetTabName(supper(pstTde->m_szTable)));
+    fprintf(stdout, "}%s;\n", sGetTabName(supper(ps->m_szTable)));
 
     if(bf)
     {
         fprintf(stdout, "\n-- Create indexes\n");
-        if(pstTde->m_lIType & UNQIUE)
+        if(ps->m_lIType & UNQIUE)
         {
-            pv = &pstTde->m_stIdxUp[0];
+            pv = &ps->m_stIdxUp[0];
             fprintf(stdout, "create unique index (%s", pv->m_szField);
-            for(i = 1; i < pstTde->m_lIdxUp; i ++)
+            for(i = 1; i < ps->m_lIdxUp; i ++)
             {
-                pv = &pstTde->m_stKey[i];
+                pv = &ps->m_stKey[i];
                 fprintf(stdout, ", %s", pv->m_szField);
             }
             fprintf(stdout, ");\n");
         }
 
-        if(pstTde->m_lIType & NORMAL)
+        if(ps->m_lIType & NORMAL)
         {
-            pv = &pstTde->m_stGrpUp[0];
+            pv = &ps->m_stGrpUp[0];
             fprintf(stdout, "create index (%s", pv->m_szField);
-            for(i = 1; i < pstTde->m_lGrpUp; i ++)
+            for(i = 1; i < ps->m_lGrpUp; i ++)
             {
-                pv = &pstTde->m_stKey[i];
+                pv = &ps->m_stKey[i];
                 fprintf(stdout, ", %s", pv->m_szField);
             }
             fprintf(stdout, ");\n");
 
         }
-        else if(pstTde->m_lIType & HASHID)
+        else if(ps->m_lIType & HASHID)
         {
-            pv = &pstTde->m_stGrpUp[0];
+            pv = &ps->m_stGrpUp[0];
             fprintf(stdout, "create hash (%s", pv->m_szField);
-            for(i = 1; i < pstTde->m_lGrpUp; i ++)
+            for(i = 1; i < ps->m_lGrpUp; i ++)
             {
-                pv = &pstTde->m_stKey[i];
+                pv = &ps->m_stKey[i];
                 fprintf(stdout, ", %s", pv->m_szField);
             }
             fprintf(stdout, ");\n");
@@ -961,7 +960,7 @@ void    vTableStruck(TABLE t)
 long    lDefineTable(char *pszCreate, char *pszTable)
 {
     long    i;
-    TblDef  stTde;
+    TblDef  sf;
     char    *p = NULL, *q = NULL;
     SATvm   *pstSavm = (SATvm *)pGetSATvm();
 
@@ -972,14 +971,14 @@ long    lDefineTable(char *pszCreate, char *pszTable)
         return RC_FAIL;
     }
 
-    memset(&stTde, 0, sizeof(TblDef));
-    if(RC_SUCC != lAnalysHead(pszCreate, p - pszCreate, &stTde))
+    memset(&sf, 0, sizeof(TblDef));
+    if(RC_SUCC != lAnalysHead(pszCreate, p - pszCreate, &sf))
         return RC_FAIL;
 
-    strncpy(stTde.m_szTable, sfieldvalue(p + 12, "\n", 1), sizeof(stTde.m_szTable));
-    srtrim(stTde.m_szTable);
-    sltrim(stTde.m_szTable);
-    supper(stTde.m_szTable);
+    strncpy(sf.m_szTable, sfieldvalue(p + 12, "\n", 1), sizeof(sf.m_szTable));
+    srtrim(sf.m_szTable);
+    sltrim(sf.m_szTable);
+    supper(sf.m_szTable);
 
     if(NULL == (q = strcasestr(p, ";")))
     {
@@ -987,22 +986,22 @@ long    lDefineTable(char *pszCreate, char *pszTable)
         return RC_FAIL;
     }
 
-    if(RC_SUCC != lAnalysTable(p + 12, q - p - 12, &stTde))
+    if(RC_SUCC != lAnalysTable(p + 12, q - p - 12, &sf))
         return RC_FAIL;
 
-    stTde.m_lReSize = sizecn(stTde.m_stKey, stTde.m_lIdxNum);
-    stTde.m_lTruck  = stTde.m_lReSize + sizeof(SHTruck);
+    sf.m_lReSize = sizecn(sf.m_stKey, sf.m_lIdxNum);
+    sf.m_lTruck  = sf.m_lReSize + sizeof(SHTruck);
 
-    if(RC_SUCC != lAnalysIndex(q + 1, strlen(q + 1), &stTde))
+    if(RC_SUCC != lAnalysIndex(q + 1, strlen(q + 1), &sf))
         return RC_FAIL;
 
-    if(RC_SUCC != lCustomTable(pstSavm, stTde.m_table, stTde.m_lMaxRow, &stTde))
+    if(RC_SUCC != lCustomTable(pstSavm, sf.m_table, sf.m_lMaxRow, &sf))
     {
         fprintf(stderr, "create table error: %s\n", sGetTError(pstSavm->m_lErrno));
         return RC_FAIL;
     }
 
-    strcpy(pszTable, stTde.m_szTable);
+    strcpy(pszTable, sf.m_szTable);
     return RC_SUCC;
 }
 
@@ -1023,7 +1022,7 @@ void    vAppendTabList(char *pszTable)
     strcat(g_stCustom.m_pszWord, ",");
 
     g_stCustom.m_lWord = lgetstrnum(g_stCustom.m_pszWord, ",");
-	return ;
+    return ;
 }
 
 /*************************************************************************************************
@@ -1223,7 +1222,7 @@ long    lShowTables(SATvm *pstSavm)
         if(!strcmp(pstIndex[i].m_szPart, pstIndex[i].m_szOwner))
             strcpy(szTable, pstIndex[i].m_szTable);
         else
-            snprintf(szTable, sizeof(szTable), "%s@%s", pstIndex[i].m_szPart, pstIndex[i].m_szTable);
+            snprintf(szTable, sizeof(szTable), "%s@%s", pstIndex[i].m_szTable, pstIndex[i].m_szPart);
         fprintf(stdout, "%3d   %s\n", pstIndex[i].m_table, szTable);
     }
 
@@ -1321,7 +1320,7 @@ void    vTableAmount()
         if(!strcmp(pstIndex[i].m_szPart, pstIndex[i].m_szOwner))
             strcpy(szTable, pstIndex[i].m_szTable);
         else
-            snprintf(szTable, sizeof(szTable), "%s@%s", pstIndex[i].m_szPart, pstIndex[i].m_szTable);
+            snprintf(szTable, sizeof(szTable), "%s@%s", pstIndex[i].m_szTable, pstIndex[i].m_szPart);
 
         vPrintAmount(pstIndex[i].m_table, pstIndex[i].m_lType, szTable, 
              lGetTblValid(pstIndex[i].m_table), lGetTblRow(pstIndex[i].m_table));
@@ -4350,8 +4349,8 @@ void    vInitialCustom()
     g_stCustom.m_pszKey = NULL;
     g_stCustom.m_pszWord = NULL;
 
-   	g_stCustom.m_pszKey = (char *)calloc(1, ALLOC_CMD_LEN);
-   	g_stCustom.m_pszWord = (char *)calloc(1, ALLOC_CMD_LEN);
+    g_stCustom.m_pszKey = (char *)calloc(1, ALLOC_CMD_LEN);
+    g_stCustom.m_pszWord = (char *)calloc(1, ALLOC_CMD_LEN);
     if(NULL == g_stCustom.m_pszKey || NULL == g_stCustom.m_pszWord)
         exit(-1);
 
@@ -4363,7 +4362,7 @@ void    vInitialCustom()
    //select nextval from SEQUENCE@SEQ_TEST
     snprintf(g_stCustom.m_pszWord, ALLOC_CMD_LEN, "SET,FROM,WHERE,COUNT(1),MAX,MIN,NEXTVAL,"
         "ORDER BY,GROUP BY,SEQUENCE@,SYS_TVM_FIELD,SYS_TVM_DOMAIN,SYS_TVM_SEQUE,TABLE,INTO,"
-        "ON,INFO,INDEX,VALUES,DEBUG [ON|OFF],SHOWMODE [ROW|COLUMN],SHOWSIZE [NUM],CLICK,");
+        "ON,INFO,INDEX,VALUES,DEBUG [ON|OFF],SHOWMODE [ROW|COLUMN],SHOWSIZE [NUM],CLICK,TO,");
     g_stCustom.m_lWord = lgetstrnum(g_stCustom.m_pszWord, ",");
  
     rl_attempted_completion_function = pMatchCompletion;
@@ -4385,7 +4384,7 @@ void    vSQLStatement(int argc, char *argv[])
     system("stty erase ^?");
     system("stty erase ^H");
     fprintf(stdout, "\n%s\n", sFuncVersion());
-	vInitialCustom();
+    vInitialCustom();
  //  initialize_readline();
     for(i = 2; i < argc; i ++)
     {
diff --git a/src/tcp.c b/src/tcp.c
index 8689145..2fa7ab4 100644
--- a/src/tcp.c
+++ b/src/tcp.c
@@ -1939,8 +1939,8 @@ void*    vEpollListen(void *pvParam)
                         }
                         pstCon->m_pstWork = NULL;
                         epoll_ctl(pstTrd->m_epfd, EPOLL_CTL_DEL, pstCon->m_skSock, &events[i]);
-                        TFree(pstCon->pstFace);
                         TFree(pstCon->pstVoid);
+                        TFree(pstCon->pstFace);
                         close(pstCon->m_skSock);
                         TFree(pstCon);
                         continue;
@@ -1975,8 +1975,8 @@ void*    vEpollListen(void *pvParam)
                     }
                     pstCon->m_pstWork = NULL;
                     epoll_ctl(pstTrd->m_epfd, EPOLL_CTL_DEL, pstCon->m_skSock, &events[i]);
-                    TFree(pstCon->pstFace);
                     TFree(pstCon->pstVoid);
+                    TFree(pstCon->pstFace);
                     close(pstCon->m_skSock);
                     TFree(pstCon);
                 }
@@ -2665,12 +2665,12 @@ long    lOfflineNotify(SATvm *pstSavm, long lPort)
  *************************************************************************************************/
 long    lPullNotify(SATvm *pstSavm, TDomain *pstDom, size_t lCount)
 {
-    TblDef  stDet;
+    TblDef  sf;
     TFace   stFace;
     void    *pvData = NULL;
     size_t  lRecv, i, lRow = 0, lValid;
 
-    memset(&stDet, 0, sizeof(TblDef));
+    memset(&sf, 0, sizeof(TblDef));
     memset(&stFace, 0, sizeof(TFace));
     stFace.m_lRows  = 0;
     stFace.m_lFind  = lCount;
@@ -2697,13 +2697,13 @@ long    lPullNotify(SATvm *pstSavm, TDomain *pstDom, size_t lCount)
     fprintf(stdout, "\nCopying table(%s)(%d) define ..", pstDom->m_szTable, pstDom->m_table);
     fflush(stdout);
     usleep(5000);
-    if(sizeof(TblDef) != lRecvBuffer(pstDom->m_skSock, (void *)&stDet, sizeof(TblDef)))
+    if(sizeof(TblDef) != lRecvBuffer(pstDom->m_skSock, (void *)&sf, sizeof(TblDef)))
         goto ERR_PULLNOTIFY;
 
-    lValid = stDet.m_lValid;
-    stDet.m_lValid = 0;
-    stDet.m_lGroup = 0;
-    if(RC_SUCC != lCustomTable(pstSavm, pstDom->m_table, stDet.m_lMaxRow, &stDet))
+    lValid = sf.m_lValid;
+    sf.m_lValid = 0;
+    sf.m_lGroup = 0;
+    if(RC_SUCC != lCustomTable(pstSavm, pstDom->m_table, sf.m_lMaxRow, &sf))
     {
         fprintf(stderr, "Create table(%d) failed, err:(%d)(%s)\n", pstDom->m_table, 
             pstSavm->m_lErrno, sGetTError(pstSavm->m_lErrno));
@@ -2711,7 +2711,7 @@ long    lPullNotify(SATvm *pstSavm, TDomain *pstDom, size_t lCount)
     }
 
     fprintf(stdout, "\b\bcompleted .\nCopy table(%s) success, table maxrow:%ld, valid:%ld "
-        " completed .\n", stDet.m_szTable, stDet.m_lMaxRow, lValid);
+        " completed .\n", sf.m_szTable, sf.m_lMaxRow, lValid);
     fflush(stdout);
     if(NULL == (pstSavm = (SATvm *)pInitSATvm(pstDom->m_table)))
     {
@@ -2723,10 +2723,10 @@ long    lPullNotify(SATvm *pstSavm, TDomain *pstDom, size_t lCount)
     fprintf(stdout, "Start Copy table(%s)(%s)rows:[", pstDom->m_szTable, pstDom->m_szPart);
     fprintf(stdout, "\033[?25l");
 
-    if(NULL == (pvData = (char *)malloc(lCount * stDet.m_lReSize))) 
+    if(NULL == (pvData = (char *)malloc(lCount * sf.m_lReSize))) 
         goto ERR_PULLNOTIFY;
 
-    pstSavm->lSize  = stDet.m_lReSize;
+    pstSavm->lSize  = sf.m_lReSize;
     while(1)
     {
         if(sizeof(TFace) != lRecvBuffer(pstDom->m_skSock, (void *)&stFace, sizeof(TFace)))
@@ -2735,13 +2735,13 @@ long    lPullNotify(SATvm *pstSavm, TDomain *pstDom, size_t lCount)
         if(0 == stFace.m_lRows)    
             break;
 
-        lRecv = stDet.m_lReSize * stFace.m_lRows;
+        lRecv = sf.m_lReSize * stFace.m_lRows;
         if(lRecv != lRecvBuffer(pstDom->m_skSock, (char *)pvData, lRecv))
             goto ERR_PULLNOTIFY;
         
         for(i = 0; i < stFace.m_lRows; i ++)
         {    
-            pstSavm->pstVoid = (void *)pvData + i * stDet.m_lReSize;
+            pstSavm->pstVoid = (void *)pvData + i * sf.m_lReSize;
             if(RC_SUCC != lInsert(pstSavm))
                 goto ERR_PULLNOTIFY;
 
diff --git a/src/tree.c b/src/tree.c
index 0b687e0..f2fd2c0 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -153,7 +153,8 @@ static char    tvmerr[128][MAX_INDEX_LEN] = {
     "queue waiting for failure",
     "created queue is too big",
     "queue does not support this operation",
-	"not connect to server",
+    "not connect to server",
+    "partion already exist",
     "",
 };
 
@@ -3195,12 +3196,13 @@ SHTree*    _pFixupInsert(void *pvData, SHTree *pstRoot, SHTree *pstCur)
     return:
         SHTree*
  *************************************************************************************************/
-SHTree*    pInsertTree(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, SHTruck **ppstTruck)
+SHTree*    pInsertTree(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               SHTruck **ppstTruck)
 {
-    int     nRet = 0;
+    int     nRet;
     size_t  lOffset;
+    void    *pvData = NULL;
     SHTree  *pstNode = NULL, *pstCur = NULL, *pstTree = pstRoot;
-    void    *pvData = NULL, *pvAddr = pGetAddr(pstSavm, pstSavm->tblName);
 
     while(SELF_POS_UNUSE != pstTree->m_lSePos && NODE_NULL != pstTree->m_lSePos)
     {
@@ -3338,12 +3340,12 @@ long    __lInsertHash(SATvm *pstSavm, void *pvAddr, TABLE t, SHTree *pstTree, si
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-SHTree* pInsertGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, SHTruck **ppstTruck)
+SHTree* pInsertGroup(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+            SHTruck **ppstTruck)
 {
     int     nRet = 0;
     size_t  lOffset;
     SHTruck *pstTruck = NULL;
-    void    *pvData = pGetAddr(pstSavm, pstSavm->tblName);
     SHTree  *pstNode = NULL, *pstCur = NULL, *pstTree = pstRoot;
 
     while(SELF_POS_UNUSE != pstTree->m_lSePos && NODE_NULL != pstTree->m_lSePos)
@@ -3354,17 +3356,17 @@ SHTree* pInsertGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, S
         {
             if(NODE_NULL == pstTree->m_lLeft)
                 break;
-            pstTree = (SHTree *)pGetNode(pvData, pstTree->m_lLeft);
+            pstTree = (SHTree *)pGetNode(pvAddr, pstTree->m_lLeft);
         }
         else if(0 > nRet)
         {
             if(NODE_NULL == pstTree->m_lRight)
                 break;
-            pstTree = (SHTree *)pGetNode(pvData, pstTree->m_lRight);
+            pstTree = (SHTree *)pGetNode(pvAddr, pstTree->m_lRight);
         }
         else 
         {
-            pCreateGroup(pvData, pstSavm->tblName, pstTree, 0, &pstTruck);
+            pCreateGroup(pvAddr, pstSavm->tblName, pstTree, 0, &pstTruck);
             if(!IS_TRUCK_NULL(pstTruck) || ((*ppstTruck) && (*ppstTruck != pstTruck)))
             {
                 pstSavm->m_lErrno = SVR_EXCEPTION;
@@ -3375,8 +3377,8 @@ SHTree* pInsertGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, S
         }
     }
 
-    lOffset = sizeof(SHTree) * ((TblDef *)pvData)->m_lGroup + lGetGrpPos(pstSavm->tblName);
-    if(NULL == (pstCur = pCreateGroup(pvData, pstSavm->tblName, NULL, lOffset, &pstTruck)))
+    lOffset = sizeof(SHTree) * ((TblDef *)pvAddr)->m_lGroup + lGetGrpPos(pstSavm->tblName);
+    if(NULL == (pstCur = pCreateGroup(pvAddr, pstSavm->tblName, NULL, lOffset, &pstTruck)))
     {
         pstSavm->m_lErrno = SVR_EXCEPTION;
         return pstRoot;
@@ -3389,7 +3391,7 @@ SHTree* pInsertGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, S
         return NULL;
     }
 
-    ((TblDef *)pvData)->m_lGroup ++;
+    ((TblDef *)pvAddr)->m_lGroup ++;
     *ppstTruck = pstTruck;
 
     pstCur->m_lIdx = lIdx;
@@ -3413,7 +3415,7 @@ SHTree* pInsertGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, S
         return pstRoot;
     }
 
-    return _pFixupInsert(pvData, pstRoot, pstCur);
+    return _pFixupInsert(pvAddr, pstRoot, pstCur);
 }
 
 /*************************************************************************************************
@@ -3694,12 +3696,12 @@ SHTree*    _pDeleteGroup(void *pvData, TABLE t, SHTree *pstRoot, SHTree *pstTree
     return:
         SHTree*
  *************************************************************************************************/
-SHTree*    pDeleteTree(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, size_t *plData)
+SHTree*    pDeleteTree(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               size_t *plData)
 {
     SHTree  *pstTree = NULL;
-    void    *pvData = pGetAddr(pstSavm, pstSavm->tblName);
 
-    if(NULL == (pstTree = pSearchTree(pvData, pstRoot, psvIdx, lIdx)))
+    if(NULL == (pstTree = pSearchTree(pvAddr, pstRoot, psvIdx, lIdx)))
     {
         pstSavm->m_lErrno = NO_DATA_FOUND;
         return NULL;
@@ -3707,7 +3709,7 @@ SHTree*    pDeleteTree(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx,
 
     *plData = pstTree->m_lData;
 
-    return _pDeleteTree(pvData, pstSavm->tblName, pstRoot, pstTree);
+    return _pDeleteTree(pvAddr, pstSavm->tblName, pstRoot, pstTree);
 }
    
 /*************************************************************************************************
@@ -3769,14 +3771,13 @@ long    _lPurgedHash(SATvm *pstSavm, void *pvAddr, SHTree *pstTree, void *pvData
     return:
         SHTree*
  *************************************************************************************************/
-SHTree*    _pRemoveGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, void *pvData, 
-            long *plOut, long eType)
+SHTree*    _pRemoveGroup(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               void *pvData, long *plOut, long eType)
 {
     SHList  *pstList = NULL;
     SHTree  *pstTree = NULL;
     SHTruck *pstTruck = NULL;
     size_t  lNext = 0, lOffset;
-    void    *pvAddr = pGetAddr(pstSavm, pstSavm->tblName);
 
     if(NULL == (pstTree = pSearchTree(pvAddr, pstRoot, psvIdx, lIdx)))
     {
@@ -3846,10 +3847,10 @@ SHTree*    _pRemoveGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lId
     return:
         SHTree*
  *************************************************************************************************/
-SHTree*    pDeleteGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, void *pvData, 
-            long *plOut)
+SHTree*    pDeleteGroup(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               void *pvData, long *plOut)
 {
-    return _pRemoveGroup(pstSavm, pstRoot, psvIdx, lIdx, pvData, plOut, 0);
+    return _pRemoveGroup(pstSavm, pvAddr, pstRoot, psvIdx, lIdx, pvData, plOut, 0);
 }
 
 /*************************************************************************************************
@@ -3865,10 +3866,10 @@ SHTree*    pDeleteGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx
     return:
         SHTree*
  *************************************************************************************************/
-SHTree*    pRemoveGroup(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, void *pvData, 
-            long *plOut)
+SHTree*    pRemoveGroup(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               void *pvData, long *plOut)
 {
-    return _pRemoveGroup(pstSavm, pstRoot, psvIdx, lIdx, pvData, plOut, 1);
+    return _pRemoveGroup(pstSavm, pvAddr, pstRoot, psvIdx, lIdx, pvData, plOut, 1);
 }
 
 /*************************************************************************************************
@@ -3928,7 +3929,7 @@ long    __lDeleteHash(SATvm *pstSavm, void *pvAddr, SHTree *pstTree, TABLE t)
                 return RC_FAIL;
             }
 
-            pstRoot = pDeleteTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), &lData);
+            pstRoot = pDeleteTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), &lData);
             if(!pstRoot || pstList->m_lData != lData)
             {
                 pthread_rwlock_unlock(prwLock);
@@ -4076,7 +4077,8 @@ long    __lDeleteIndex(SATvm *pstSavm, void *pvAddr, TABLE t, void *psvIdx)
             return RC_FAIL;
         }    
 
-        if(NULL == (pstRoot = pDeleteGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), &lData, &lRow)))
+        if(NULL == (pstRoot = pDeleteGroup(pstSavm, pvAddr, pstRoot, szIdx, lGetGrpLen(t), 
+            &lData, &lRow)))
         {    
             pthread_rwlock_unlock(prwLock);
             return RC_FAIL;
@@ -4234,7 +4236,7 @@ long    __lDeleteGroup(SATvm *pstSavm, void *pvAddr, TABLE t, void *psvIdx)
                 return RC_FAIL;
             }
 
-            pstIRoot = pDeleteTree(pstSavm, pstIRoot, szIdx, lGetIdxLen(t), &lData);
+            pstIRoot = pDeleteTree(pstSavm, pvAddr, pstIRoot, szIdx, lGetIdxLen(t), &lData);
             if(!pstIRoot || pstList->m_lData != lData)
             {
                 pthread_rwlock_unlock(prwLock);
@@ -4362,7 +4364,7 @@ long    _lDeleteTruck(SATvm *pstSavm, void *pvAddr, TABLE t)
                 return RC_FAIL;
             }
 
-            pstRoot = pDeleteTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), &lData);
+            pstRoot = pDeleteTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), &lData);
             if(!pstRoot || lOffset != lData)
             {
                 pthread_rwlock_unlock(prwLock);
@@ -4390,8 +4392,10 @@ long    _lDeleteTruck(SATvm *pstSavm, void *pvAddr, TABLE t)
                 return RC_FAIL;
             }
 
-            pstRoot = pDeleteGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), &lOffset, (long *)&lData);
-            if(!pstRoot)    return RC_FAIL;
+            if(NULL == (pstRoot = pDeleteGroup(pstSavm, pvAddr, pstRoot, szIdx, lGetGrpLen(t), 
+                &lOffset, (long *)&lData)))
+                return RC_FAIL;
+
             if(1 != lData)
             {
                 pthread_rwlock_unlock(prwLock);
@@ -4829,11 +4833,12 @@ long    lCount(SATvm *pstSavm, size_t *plCount)
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-SHTree*    pRebuildTree(SATvm *pstSavm, SHTree *pstRoot, void *psvIdx, long lIdx, long lRow, size_t lData)
+SHTree*    pRebuildTree(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, void *psvIdx, long lIdx, 
+               long lRow, size_t lData)
 {
     int     nRet = 0;
+    void    *pvData = NULL;
     size_t  lOffset, lPos = 0, lNext = 0;
-    void    *pvData = NULL, *pvAddr = pGetAddr(pstSavm, pstSavm->tblName);
     SHTree  *pstNode = NULL, *pstCur = NULL, *pstNext = NULL, *pstTree = pstRoot;
 
     while(SELF_POS_UNUSE != pstTree->m_lSePos && NODE_NULL != pstTree->m_lSePos)
@@ -5014,12 +5019,12 @@ long    lRebuildHash(SATvm *pstSavm, TABLE t, void *pvAddr, SHTree *pstTree, siz
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-SHTree*    pRebuildGroup(SATvm *pstSavm, SHTree *pstRoot, char *psvIdx, long lIdx, long lRow, size_t lData)
+SHTree*    pRebuildGroup(SATvm *pstSavm, void *pvAddr, SHTree *pstRoot, char *psvIdx, long lIdx, 
+               long lRow, size_t lData)
 {
     int     nRet;
     size_t  lOffset;
     SHTruck *pstTruck = NULL;
-    void    *pvAddr = pGetAddr(pstSavm, pstSavm->tblName);
     SHTree  *pstNode = NULL, *pstCur = NULL, *pstTree = pstRoot;
 
     while(SELF_POS_UNUSE != pstTree->m_lSePos && NODE_NULL != pstTree->m_lSePos)
@@ -5199,7 +5204,7 @@ long    _lRebuildIndex(SATvm *pstSavm, void *pvAddr)
             }
 
             pstIRoot = (SHTree *)pGetNode(pvAddr, ((TblDef *)pvAddr)->m_lTreeRoot);
-            pstIRoot = pRebuildTree(pstSavm, pstIRoot, szIdx, lGetIdxLen(t), lRow, lOffset);
+            pstIRoot = pRebuildTree(pstSavm, pvAddr, pstIRoot, szIdx, lGetIdxLen(t), lRow, lOffset);
             if(!pstIRoot)    return RC_FAIL;
 
             ((TblDef *)pvAddr)->m_lTreeRoot = pstIRoot->m_lSePos;
@@ -5215,7 +5220,7 @@ long    _lRebuildIndex(SATvm *pstSavm, void *pvAddr)
             }
 
             pstGRoot = (SHTree *)pGetNode(pvAddr, ((TblDef *)pvAddr)->m_lGroupRoot);
-            pstGRoot = pRebuildGroup(pstSavm, pstGRoot, szIdx, lGetGrpLen(t), lRow, lOffset);
+            pstGRoot = pRebuildGroup(pstSavm, pvAddr, pstGRoot, szIdx, lGetGrpLen(t), lRow, lOffset);
             if(!pstGRoot)    return RC_FAIL;
 
             ((TblDef *)pvAddr)->m_lGroupRoot = pstGRoot->m_lSePos;
@@ -6171,38 +6176,64 @@ long    _lQueryGroup(SATvm *pstSavm, void *pvAddr, TABLE t, size_t *plOut, void
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    _lQueryTruck(SATvm *pstSavm, void *pvAddr, TABLE t, size_t *plOut, void **ppsvOut)
+long    _lQueryTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, size_t *plOut, void **ppsvOut)
 {
     SHTruck *pstTruck = NULL;
-    size_t  lRow = 0, lOffset = lGetTblData(t), lPos = 0;
+    size_t  lRow = 0, lOffset, lPos = 0;
+    TblDef  *pv = (TblDef *)pstRun->m_pvAddr;
 
-    pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset);
-    for(lRow = 0, *plOut = 0; (lRow < ((TblDef *)pvAddr)->m_lValid) && (lOffset < lGetTableSize(t)); 
-        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset))
-    {        
-        if(IS_TRUCK_NULL(pstTruck))
+    if(TYPE_MQUEUE == pstRun->m_lType)
+    {
+        lOffset = pv->m_lListOfs + 1;
+        for((*plOut) = 0, lRow = 0; lRow < pv->m_lMaxRow; lOffset ++, lRow ++)
         {
+            pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, 
+                pv->m_lData + pv->m_lTruck * (lOffset % pv->m_lMaxRow));
+            if(IS_TRUCK_NULL(pstTruck))
+                continue;
+
+            lPos = (++ (*plOut)) * pv->m_lReSize;
+            if(NULL == (*ppsvOut = (char *)realloc(*ppsvOut, lPos)))
+            {
+                pstSavm->m_lErrno = MALLC_MEM_ERR;
+                return RC_FAIL;
+            }
+
+            pstTruck->m_lTimes ++;
+            memcpy(*ppsvOut + (lPos - pv->m_lReSize), pstTruck->m_pvData, pv->m_lReSize);
+        }
+    }
+    else
+    {
+        lOffset = lGetTblData(t);
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset);
+        for(lRow = 0, *plOut = 0; (lRow < pv->m_lValid) && (lOffset < lGetTableSize(t)); 
+            pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset))
+        {        
+            if(IS_TRUCK_NULL(pstTruck))
+            {
+                lOffset += lGetRowTruck(t);
+                continue;
+            }
+
+            lRow ++;
+            if(RC_MISMA == lFeildMatch(&pstSavm->stCond, pstTruck->m_pvData, pstSavm->pstVoid))
+            {
+                lOffset += lGetRowTruck(t);
+                continue;
+            }
+            
+            lPos = (++ (*plOut)) * pv->m_lReSize;
+            if(NULL == (*ppsvOut = (char *)realloc(*ppsvOut, lPos)))
+            {
+                pstSavm->m_lErrno = MALLC_MEM_ERR;
+                return RC_FAIL;
+            }
+
+            pstTruck->m_lTimes ++;
+            memcpy(*ppsvOut + (lPos - pv->m_lReSize), pstTruck->m_pvData, pv->m_lReSize);
             lOffset += lGetRowTruck(t);
-            continue;
         }
-
-        lRow ++;
-        if(RC_MISMA == lFeildMatch(&pstSavm->stCond, pstTruck->m_pvData, pstSavm->pstVoid))
-        {
-            lOffset += lGetRowTruck(t);
-            continue;
-        }
-        
-        lPos = (++ (*plOut)) * lGetRowSize(t);
-        if(NULL == (*ppsvOut = (char *)realloc(*ppsvOut, lPos)))
-        {
-            pstSavm->m_lErrno = MALLC_MEM_ERR;
-            return RC_FAIL;
-        }
-
-        pstTruck->m_lTimes ++;
-        memcpy(*ppsvOut + (lPos - lGetRowSize(t)), pstTruck->m_pvData, lGetRowSize(t));
-        lOffset += lGetRowTruck(t);
     }
 
     if(0 == (pstSavm->m_lEffect = *plOut))
@@ -6269,7 +6300,7 @@ long    _lQuery(SATvm *pstSavm, RunTime *pstRun, size_t *plOut, void **ppsvOut)
     }
 
     pstSavm->m_lEType = EXE_PLAN_ALL;
-    lRet = _lQueryTruck(pstSavm, pstRun->m_pvAddr, pstSavm->tblName, plOut, ppsvOut);
+    lRet = _lQueryTruck(pstSavm, pstRun, pstSavm->tblName, plOut, ppsvOut);
     pthread_rwlock_unlock(prwLock);
 
     return lRet;
@@ -6416,7 +6447,7 @@ long    _lInsertIndex(SATvm *pstSavm, void *pvAddr, TABLE t, SHTruck **ppstTruck
         return RC_FAIL;
     }
 
-    pstRoot = pInsertTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), ppstTruck);
+    pstRoot = pInsertTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), ppstTruck);
     if(!pstRoot)    return RC_FAIL;
 
     ((TblDef *)pvAddr)->m_lTreeRoot = pstRoot->m_lSePos;
@@ -6488,7 +6519,7 @@ long    _lInsertGroup(SATvm *pstSavm, void *pvAddr, TABLE t, SHTruck **ppstTruck
         return RC_FAIL;
     }
 
-    pstRoot = pInsertGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), ppstTruck);
+    pstRoot = pInsertGroup(pstSavm, pvAddr, pstRoot, szIdx, lGetGrpLen(t), ppstTruck);
     if(!pstRoot)    return RC_FAIL;
 
     ((TblDef *)pvAddr)->m_lGroupRoot = pstRoot->m_lSePos;    
@@ -6580,23 +6611,43 @@ long    __lInsert(SATvm *pstSavm, RunTime *pstRun, TABLE t, ulong uTimes)
         vIncrease(&pstSavm->stUpdt, (char *)pstSavm->pstVoid, (TblDef *)pstRun->m_pvAddr);
 
     if(TYPE_MQUEUE == pstRun->m_lType)
-        return _lPush(pstSavm, pstRun->m_pvAddr);
+    {
+        if(RC_SUCC != _lPush(pstSavm, pstRun->m_pvAddr))
+        {
+            if(FIELD_INCR & pstSavm->lFind)
+                ((TblDef *)pstRun->m_pvAddr)->m_lExSeQ --;
+        }
 
+        return RC_SUCC;
+    }
+  
     if(HAVE_UNIQ_IDX(t))
     {
         if(RC_SUCC != _lInsertIndex(pstSavm, pstRun->m_pvAddr, t, &pstTruck))
+        {
+            if(FIELD_INCR & pstSavm->lFind)
+                ((TblDef *)pstRun->m_pvAddr)->m_lExSeQ --;
             return RC_FAIL;
+        }
     }
 
     if(HAVE_NORL_IDX(t))
     {
         if(RC_SUCC != _lInsertGroup(pstSavm, pstRun->m_pvAddr, t, &pstTruck))
+        {
+            if(FIELD_INCR & pstSavm->lFind)
+                ((TblDef *)pstRun->m_pvAddr)->m_lExSeQ --;
             return RC_FAIL;
+        }
     }
     else if(HAVE_HASH_IDX(t))
     {
         if(RC_SUCC != _lInsertHash(pstSavm, pstRun->m_pvAddr, t, &pstTruck))
+        {
+            if(FIELD_INCR & pstSavm->lFind)
+                ((TblDef *)pstRun->m_pvAddr)->m_lExSeQ --;
             return RC_FAIL;
+        }
     }
 
     return _lInsertTruck(pstSavm, pstRun->m_pvAddr, t, pstTruck, uTimes);
@@ -6786,12 +6837,12 @@ ErrInsert:
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    _llFetchIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
+long    _lFetchIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
 {
     SHTree  *pstTree = NULL;
     SHTruck *pstTruck = NULL;
     char    szIdx[MAX_INDEX_LEN];
-    void    *pvAddr = pGetAddr(pstSavm, t);
+    void    *pvAddr = pstRun->m_pvAddr;
 
     memset(szIdx, 0, sizeof(szIdx));
     if(NULL == pPickIndex(lGetIdxNum(t), pGetTblIdx(t), pstRun->pstVoid, szIdx))
@@ -6838,17 +6889,16 @@ long    _llFetchIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    _llFetchGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
+long    _lFetchGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
 {
     SHList  *pstList = NULL;
     SHTruck *pstTruck = NULL;
     char    szIdx[MAX_INDEX_LEN];
-    void    *pvAddr = pGetAddr(pstSavm, t);
 
     for(pstList = (SHList *)pstRun->m_pvCurAddr; pstList && (SELF_POS_UNUSE != pstList->m_lPos); 
-        pstList = (SHList *)pGetNode(pvAddr, pstList->m_lNext))
+        pstList = (SHList *)pGetNode(pstRun->m_pvAddr, pstList->m_lNext))
     {
-        pstTruck = (PSHTruck)pGetNode(pvAddr, pstList->m_lData);
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, pstList->m_lData);
         if(IS_TRUCK_NULL(pstTruck))
         {
             if(SELF_POS_UNUSE == pstList->m_lNext)    break;
@@ -6866,7 +6916,7 @@ long    _llFetchGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
         if(SELF_POS_UNUSE == pstList->m_lNext)
             pstRun->m_pvCurAddr = NULL;
         else
-            pstRun->m_pvCurAddr = (void *)pGetNode(pvAddr, pstList->m_lNext);
+            pstRun->m_pvCurAddr = (void *)pGetNode(pstRun->m_pvAddr, pstList->m_lNext);
 
         return RC_SUCC;
     }
@@ -6885,25 +6935,24 @@ long    _llFetchGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
         RC_SUCC                    --success
         RC_FAIL                    --failure
  *************************************************************************************************/
-long    _llFetchTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
+long    _lFetchTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
 {
     SHTruck *pstTruck = NULL;
     long    lRow = 0, lOffset;
-    void    *pvAddr = pGetAddr(pstSavm, t);
 
     if(1 == pstRun->m_lCurLine)
     {
         lOffset = lGetTblData(t);
-        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset);
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset);
     }
     else
     {
-        lOffset = pstRun->m_pvCurAddr - pvAddr;
+        lOffset = pstRun->m_pvCurAddr - pstRun->m_pvAddr;
         pstTruck = (PSHTruck)pstRun->m_pvCurAddr;
     }
 
-    for(lRow = 0; (lRow < ((TblDef *)pvAddr)->m_lValid) && (lOffset < lGetTableSize(t));
-        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset))
+    for(lRow = 0; (lRow < ((TblDef *)pstRun->m_pvAddr)->m_lValid) && (lOffset < lGetTableSize(t));
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset))
     {
         if(IS_TRUCK_NULL(pstTruck))
         {
@@ -6920,7 +6969,7 @@ long    _llFetchTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
 
         pstRun->m_lCurLine ++;
         lOffset += lGetRowTruck(t);
-        pstRun->m_pvCurAddr = pGetNode(pvAddr, lOffset);
+        pstRun->m_pvCurAddr = pGetNode(pstRun->m_pvAddr, lOffset);
         memcpy(psvOut, pstTruck->m_pvData, lGetRowSize(t));
         return RC_SUCC;
     }
@@ -7053,11 +7102,11 @@ long    lTableFetch(SATvm *pstSavm, void *psvOut)
     }
 
     if(EXE_PLAN_IDX == pstRun->m_lCurType)
-        lRet = _llFetchIndex(pstSavm, pstRun, pstSavm->tblName, psvOut);
+        lRet = _lFetchIndex(pstSavm, pstRun, pstSavm->tblName, psvOut);
     else if(EXE_PLAN_GRP == pstRun->m_lCurType)
-        lRet = _llFetchGroup(pstSavm, pstRun, pstSavm->tblName, psvOut);
+        lRet = _lFetchGroup(pstSavm, pstRun, pstSavm->tblName, psvOut);
     else
-        lRet = _llFetchTruck(pstSavm, pstRun, pstSavm->tblName, psvOut);
+        lRet = _lFetchTruck(pstSavm, pstRun, pstSavm->tblName, psvOut);
     if(RC_NOTFOUND == lRet)
     {
         pstRun->m_pvCurAddr = NULL;
@@ -7082,21 +7131,20 @@ long    _lNextTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
 {
     SHTruck *pstTruck = NULL;
     long    lRow = 0, lOffset;
-    void    *pvAddr = pGetAddr(pstSavm, t);
 
     if(1 == pstRun->m_lCurLine)
     {
         lOffset = lGetTblData(t);
-        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset);
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset);
     }
     else
     {
-        lOffset = pstRun->m_pvCurAddr - pvAddr;
+        lOffset = pstRun->m_pvCurAddr - pstRun->m_pvAddr;
         pstTruck = (PSHTruck)pstRun->m_pvCurAddr;
     }
 
-    for(lRow = 0; (lRow < ((TblDef *)pvAddr)->m_lValid) && (lOffset < lGetTableSize(t));
-        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset))
+    for(lRow = 0; (lRow < ((TblDef *)pstRun->m_pvAddr)->m_lValid) && (lOffset < lGetTableSize(t));
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset))
     {
         if(IS_TRUCK_NULL(pstTruck))
         {
@@ -7114,7 +7162,7 @@ long    _lNextTruck(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
         pstRun->m_lCurLine ++;
         *ppvOAddr = pstTruck->m_pvData;
         lOffset += lGetRowTruck(t);
-        pstRun->m_pvCurAddr = pGetNode(pvAddr, lOffset);
+        pstRun->m_pvCurAddr = pGetNode(pstRun->m_pvAddr, lOffset);
         return RC_SUCC;
     }
 
@@ -7137,12 +7185,11 @@ long    _lNextGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
     SHList  *pstList = NULL;
     SHTruck *pstTruck = NULL;
     char    szIdx[MAX_INDEX_LEN];
-    void    *pvAddr = pGetAddr(pstSavm, t);
 
     for(pstList = (SHList *)pstRun->m_pvCurAddr; pstList && (SELF_POS_UNUSE != pstList->m_lPos); 
-        pstList = (SHList *)pGetNode(pvAddr, pstList->m_lNext))
+        pstList = (SHList *)pGetNode(pstRun->m_pvAddr, pstList->m_lNext))
     {
-        pstTruck = (PSHTruck)pGetNode(pvAddr, pstList->m_lData);
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, pstList->m_lData);
         if(RC_MISMA == lFeildMatch(&pstSavm->stCond, pstTruck->m_pvData, pstRun->pstVoid))
         {
             if(SELF_POS_UNUSE == pstList->m_lNext)    break;
@@ -7154,7 +7201,7 @@ long    _lNextGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
         if(SELF_POS_UNUSE == pstList->m_lNext)
             pstRun->m_pvCurAddr = NULL;
         else
-            pstRun->m_pvCurAddr = (void *)pGetNode(pvAddr, pstList->m_lNext);
+            pstRun->m_pvCurAddr = (void *)pGetNode(pstRun->m_pvAddr, pstList->m_lNext);
 
         return RC_SUCC;
     }
@@ -7178,7 +7225,6 @@ long    _lNextIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
     SHTree  *pstTree = NULL;
     SHTruck *pstTruck = NULL;
     char    szIdx[MAX_INDEX_LEN];
-    void    *pvAddr = pGetAddr(pstSavm, t);
 
     memset(szIdx, 0, sizeof(szIdx));
     if(NULL == pPickIndex(lGetIdxNum(t), pGetTblIdx(t), pstSavm->pstVoid, szIdx))
@@ -7187,20 +7233,21 @@ long    _lNextIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void **ppvOAddr)
         return RC_FAIL;
     }
 
-    if(NULL == (pstTree = (SHTree *)pGetNode(pvAddr, ((TblDef *)pvAddr)->m_lTreeRoot)))
+    if(NULL == (pstTree = (SHTree *)pGetNode(pstRun->m_pvAddr, 
+        ((TblDef *)pstRun->m_pvAddr)->m_lTreeRoot)))
     {   
         pstSavm->m_lErrno = SVR_EXCEPTION;
         return RC_FAIL;
     }
 
-    pstTree = (SHTree *)pSearchTree(pvAddr, pstTree, szIdx, lGetIdxLen(t));
+    pstTree = (SHTree *)pSearchTree(pstRun->m_pvAddr, pstTree, szIdx, lGetIdxLen(t));
     if(!pstTree)
     {
         pstSavm->m_lErrno = NO_DATA_FOUND;
         return RC_NOTFOUND;
     }
 
-    pstTruck = (PSHTruck)pGetNode(pvAddr, pstTree->m_lData);
+    pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, pstTree->m_lData);
     if(RC_MISMA == lFeildMatch(&pstSavm->stCond, pstTruck->m_pvData, pstRun->pstVoid))
     {
         pstSavm->m_lErrno = NO_DATA_FOUND;
@@ -7445,7 +7492,7 @@ long    __lUpdateGroup(SATvm *pstSavm, void *pvAddr, TABLE t, SHTruck *pstTruck,
         return RC_FAIL;
     }
 
-    if(NULL == (pstRoot = pInsertGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), &pstTruck)))
+    if(NULL == (pstRoot = pInsertGroup(pstSavm, pvAddr, pstRoot, szIdx, lGetGrpLen(t), &pstTruck)))
         return RC_FAIL;
 
     ((TblDef *)pvAddr)->m_lValid ++;
@@ -7520,7 +7567,7 @@ long   __lIndexUpdate(SATvm *pstSavm, void *pvAddr, TABLE t, SHTruck *pstTruck,
     }
     ((TblDef *)pvAddr)->m_lValid --;
 
-    if(NULL == (pstRoot = pInsertTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
+    if(NULL == (pstRoot = pInsertTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
         return RC_FAIL;
     ((TblDef *)pvAddr)->m_lValid ++;
     ((TblDef *)pvAddr)->m_lTreeRoot = pstRoot->m_lSePos;
@@ -7640,7 +7687,7 @@ long    _lUpdateIndex(SATvm *pstSavm, void *pvAddr, TABLE t, void *pvUpdate)
         }
         
         ((TblDef *)pvAddr)->m_lValid --;
-        if(NULL == (pstRoot = pInsertTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
+        if(NULL == (pstRoot = pInsertTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
         {
             SET_DATA_TRUCK(pstTruck, DATA_TRUCK_NRML);
             pthread_rwlock_unlock(prwLock);    
@@ -7783,7 +7830,8 @@ long    _lUpdateGroup(SATvm *pstSavm, void *pvAddr, TABLE t, void *pvUpdate)
                 ((TblDef *)pvAddr)->m_lGroupRoot = pstRoot->m_lSePos;
             }
 
-            if(NULL == (pstRoot = pInsertGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), &pstTruck)))
+            if(NULL == (pstRoot = pInsertGroup(pstSavm, pvAddr, pstRoot, szIdx, 
+                lGetGrpLen(t), &pstTruck)))
             {
                 SET_DATA_TRUCK(pstTruck, DATA_TRUCK_NRML);
                 goto REPGROUP_ERROR;
@@ -8149,7 +8197,7 @@ long    lUpdate(SATvm *pstSavm, void *pvUpdate)
  *************************************************************************************************/
 long    lRegisterTable(SATvm *pstSavm, RunTime *pstRun, TABLE t, long lType)
 {
-    TIndex  stIndex;
+    TIndex  stIndex, stPartion;
     TBoot   *pstBoot = (TBoot *)pBootInitial();
 
     if(TYPE_SYSTEM == lType || TYPE_INCORE == lType)
@@ -8163,6 +8211,17 @@ long    lRegisterTable(SATvm *pstSavm, RunTime *pstRun, TABLE t, long lType)
 
     pstRun->m_semID = semget(pstSavm->m_ySey, pstBoot->m_lMaxTable, IPC_CREAT|0660);
 
+    conditinit(pstSavm, stPartion, SYS_TVM_INDEX);
+    conditstr(pstSavm, stPartion, m_szTable, sGetTableName(t));
+    conditstr(pstSavm, stPartion, m_szPart, sGetTablePart(t, pstSavm->m_szNode));
+    if(RC_SUCC == lSelect(pstSavm, (void *)&stPartion))
+    {
+        pstSavm->m_lErrno = PART_AR_EXIST;
+        return RC_FAIL; 
+    }
+    else if(NO_DATA_FOUND != pstSavm->m_lErrno)
+        return RC_FAIL;
+
     conditinit(pstSavm, stIndex, SYS_TVM_INDEX);
     stIndex.m_lValid   = 0;
     stIndex.m_yKey     = 0;
@@ -8177,8 +8236,8 @@ long    lRegisterTable(SATvm *pstSavm, RunTime *pstRun, TABLE t, long lType)
 
     strncpy(stIndex.m_szOwner, pstSavm->m_szNode, sizeof(stIndex.m_szOwner));
     strncpy(stIndex.m_szTime, sGetUpdTime(), sizeof(stIndex.m_szTime));
-    strncpy(stIndex.m_szTable, sGetTableName(t), sizeof(stIndex.m_szTable));
-    strncpy(stIndex.m_szPart, sGetTablePart(t, pstSavm->m_szNode), sizeof(stIndex.m_szPart));
+    strncpy(stIndex.m_szTable, stPartion.m_szTable, sizeof(stIndex.m_szTable));
+    strncpy(stIndex.m_szPart, stPartion.m_szPart, sizeof(stIndex.m_szPart));
 
     if(RC_SUCC != lInsert(pstSavm))
     {
@@ -9190,7 +9249,7 @@ long    lExportTable(TABLE t, size_t *plOut, void **ppsvOut)
     }
 
     pstSavm->pstVoid = NULL;
-    lRet = _lQueryTruck(pstSavm, pstRun->m_pvAddr, t, plOut, ppsvOut);
+    lRet = _lQueryTruck(pstSavm, pstRun, t, plOut, ppsvOut);
     vTblDisconnect(pstSavm, pstSavm->tblName);
     if(NO_DATA_FOUND == pstSavm->m_lErrno)
         return RC_SUCC;
@@ -9253,6 +9312,37 @@ long    lImportTable(TABLE t, size_t lCount, void *psvData)
     return lRet;
 }
 
+/*************************************************************************************************
+    description：Queue-fetch the data as truck
+    parameters:
+        pstSavm                    --stvm handle
+        pstRun                     --table handle
+        t                          --table 
+        psvout                     --result data
+    return:
+        RC_SUCC                    --success
+        RC_FAIL                    --failure
+ *************************************************************************************************/
+long    _lFetchQueue(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *psvOut)
+{
+    SHTruck *pstTruck = NULL;
+    TblDef  *pv = (TblDef *)pstRun->m_pvAddr;
+    size_t  lRow, lOffset = pv->m_lListOfs + 1;
+
+    for(; pstRun->m_lCurLine <= pv->m_lMaxRow; lOffset ++, pstRun->m_lCurLine ++)
+    {
+        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, 
+            pv->m_lData + pv->m_lTruck * (lOffset % pv->m_lMaxRow));
+        if(IS_TRUCK_NULL(pstTruck))
+            continue;
+
+        memcpy(psvOut, pstTruck->m_pvData, pv->m_lReSize);
+        return RC_SUCC;
+    }
+
+    return RC_NOTFOUND;
+}
+
 /*************************************************************************************************
     description：Export the memory table to a file
     parameters:
@@ -9312,7 +9402,7 @@ long    lExportFile(TABLE t, char *pszFile, char *pszFlag)
     pstRun->m_pvCurAddr = pstRun->m_pvAddr;    
     if(TYPE_MQUEUE == pstRun->m_lType)
     {
-        while(RC_NOTFOUND != _llFetchTruck(pstSavm, pstRun, t, psvOut))
+        while(RC_NOTFOUND != _lFetchQueue(pstSavm, pstRun, t, psvOut))
         {
             fwrite(psvOut, 1, lGetRowSize(t), fp);
             fprintf(fp, "\n");
@@ -9320,7 +9410,7 @@ long    lExportFile(TABLE t, char *pszFile, char *pszFlag)
     }
     else
     {
-        while(RC_NOTFOUND != _llFetchTruck(pstSavm, pstRun, t, psvOut))
+        while(RC_NOTFOUND != _lFetchTruck(pstSavm, pstRun, t, psvOut))
         {
             _lExportContext(fp, psvOut, lGetFldNum(t), pGetTblKey(t), pszFlag);
             fprintf(fp, "\n");
@@ -9500,12 +9590,12 @@ long    lRenameTable(SATvm *pstSavm, TABLE to, TABLE tn)
     conditnum(pstSavm, stField, m_table, to);
     updatenum(pstSavm, stNFld, m_table, tn);
     if(RC_SUCC != lUpdate(pstSavm, &stNFld))
-	{
-		if(NO_DATA_FOUND != pstSavm->m_lErrno)
-	        return RC_FAIL;
-	}
-	
-	return RC_SUCC;
+    {
+        if(NO_DATA_FOUND != pstSavm->m_lErrno)
+            return RC_FAIL;
+    }
+
+    return RC_SUCC;
 }
 
 /*************************************************************************************************
@@ -10405,7 +10495,7 @@ long    _lReplaceIndex(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *pvUpdate)
         }
         
         ((TblDef *)pvAddr)->m_lValid --;
-        if(NULL == (pstRoot = pInsertTree(pstSavm, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
+        if(NULL == (pstRoot = pInsertTree(pstSavm, pvAddr, pstRoot, szIdx, lGetIdxLen(t), &pstTruck)))
         {
             SET_DATA_TRUCK(pstTruck, DATA_TRUCK_NRML);
             pthread_rwlock_unlock(prwLock);    
@@ -10552,7 +10642,8 @@ long    _lReplaceGroup(SATvm *pstSavm, RunTime *pstRun, TABLE t, void *pvUpdate)
                 ((TblDef *)pvAddr)->m_lGroupRoot = pstRoot->m_lSePos;
             }
 
-            if(NULL == (pstRoot = pInsertGroup(pstSavm, pstRoot, szIdx, lGetGrpLen(t), &pstTruck)))
+            if(NULL == (pstRoot = pInsertGroup(pstSavm, pvAddr, pstRoot, szIdx, 
+                lGetGrpLen(t), &pstTruck)))
             {
                 SET_DATA_TRUCK(pstTruck, DATA_TRUCK_NRML);
                 goto GROUP_ERROR;
@@ -10912,6 +11003,66 @@ long    lReplace(SATvm *pstSavm, void *pvReplace)
     return lRet;
 }
 
+/*************************************************************************************************
+    description：dump the table data to file
+    parameters:
+        pstSavm                    --stvm handle
+        t                          --table
+    return:
+        RC_SUCC                    --success
+        RC_FAIL                    --failure
+ *************************************************************************************************/
+void    _vDumpTable(SATvm *pstSavm, void *pvAddr, FILE *fp)
+{
+    SHTruck *pstTruck = NULL;
+    TblDef  *pv = (TblDef *)pvAddr;
+    size_t  lRow, lOffset = pv->m_lData;
+
+    for(lRow = 0; (lRow < pv->m_lValid) && (lOffset < pv->m_lTable); lOffset += pv->m_lTruck)
+    {
+        pstTruck = (PSHTruck)pGetNode(pvAddr, lOffset);
+        if(IS_TRUCK_NULL(pstTruck))
+            continue;
+
+        lRow ++;
+        fwrite(pstTruck->m_pvData, pv->m_lReSize, 1, fp);
+        fwrite((void *)&pstTruck->m_lTimes, sizeof(ulong), 1, fp);
+    }
+
+    pstSavm->m_lEffect = lRow;
+
+    return ;
+}
+
+/*************************************************************************************************
+    description：dump the queue data to file
+    parameters:
+        pstSavm                    --stvm handle
+        t                          --table
+    return:
+        RC_SUCC                    --success
+        RC_FAIL                    --failure
+ *************************************************************************************************/
+void    _vDumpQueue(SATvm *pstSavm, void *pvAddr, FILE *fp)
+{
+    SHTruck *pstTruck = NULL;
+    TblDef  *pv = (TblDef *)pvAddr;
+    size_t  lRow, lOffset = pv->m_lListOfs;
+
+    for(pstSavm->m_lEffect = 0, lRow = 0; lRow < pv->m_lMaxRow; lOffset ++, lRow ++)
+    {
+        pstTruck = (PSHTruck)pGetNode(pvAddr, pv->m_lData + pv->m_lTruck * (lOffset % pv->m_lMaxRow));
+        if(IS_TRUCK_NULL(pstTruck))
+            continue;
+
+        pstSavm->m_lEffect ++;
+        fwrite(pstTruck->m_pvData, pv->m_lReSize, 1, fp);
+        fwrite((void *)&pstTruck->m_lTimes, sizeof(ulong), 1, fp);
+    }
+
+    return ;
+}
+
 /*************************************************************************************************
     description：dump the table data
     parameters:
@@ -10926,8 +11077,6 @@ long    lDumpTable(SATvm *pstSavm, TABLE t)
     FILE    *fp = NULL;
     char    szFile[512];
     RunTime *pstRun = NULL;
-    SHTruck *pstTruck = NULL;
-    size_t  lRow = 0, lOffset;
 
     if(!pstSavm)
     {
@@ -10956,25 +11105,11 @@ long    lDumpTable(SATvm *pstSavm, TABLE t)
     }
     fwrite(pGetTblDef(t), sizeof(TblDef), 1, fp);
 
-    lOffset = lGetTblData(t);
-    pstRun->m_lCurLine = 0;
     pstSavm->lSize = lGetRowSize(t);
-    pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset);
-    for(lRow = 0; (lRow < ((TblDef *)pstRun->m_pvAddr)->m_lValid) && (lOffset < lGetTableSize(t));
-        pstTruck = (PSHTruck)pGetNode(pstRun->m_pvAddr, lOffset))
-    {
-        if(IS_TRUCK_NULL(pstTruck))
-        {
-            lOffset += lGetRowTruck(t);
-            continue;
-        }
-
-        fwrite(pstTruck->m_pvData, lGetRowSize(t), 1, fp);
-        fwrite((void *)&pstTruck->m_lTimes, sizeof(ulong), 1, fp);
-
-        pstSavm->m_lEffect ++;
-        lOffset += lGetRowTruck(t);
-    }
+    if(TYPE_MQUEUE == pstRun->m_lType)
+        _vDumpQueue(pstSavm, pstRun->m_pvAddr, fp);
+    else
+        _vDumpTable(pstSavm, pstRun->m_pvAddr, fp);
     fclose(fp);
     vTableClose(pstSavm);
 
@@ -10994,7 +11129,7 @@ long    lDumpTable(SATvm *pstSavm, TABLE t)
  *************************************************************************************************/
 long    lMountTable(SATvm *pstSavm, char *pszFile)
 {
-    TblDef  stTde;
+    TblDef  sf;
     FILE    *fp = NULL;
     long    lEffect = 0;
     void    *pvData = NULL;
@@ -11014,21 +11149,21 @@ long    lMountTable(SATvm *pstSavm, char *pszFile)
         return RC_FAIL;
     }
 
-    fread(&stTde, sizeof(TblDef), 1, fp);
-    if(RC_SUCC != lInitSATvm(pstSavm, stTde.m_table))
+    fread(&sf, sizeof(TblDef), 1, fp);
+    if(RC_SUCC != lInitSATvm(pstSavm, sf.m_table))
         goto MOUNT_ERROR;
 
-    if(NULL == (pstRun = (RunTime *)pInitHitTest(pstSavm, stTde.m_table)))
+    if(NULL == (pstRun = (RunTime *)pInitHitTest(pstSavm, sf.m_table)))
         goto MOUNT_ERROR;
 
-    if(stTde.m_lReSize != lGetRowSize(stTde.m_table))
+    if(sf.m_lReSize != lGetRowSize(sf.m_table))
     {
         vTblDisconnect(pstSavm, pstSavm->tblName);
         pstSavm->m_lErrno = VER_NOT_MATCH;
         goto MOUNT_ERROR;
     }
 
-    if(NULL == (pvData = (void *)malloc(stTde.m_lReSize)))
+    if(NULL == (pvData = (void *)malloc(sf.m_lReSize)))
     {
         vTblDisconnect(pstSavm, pstSavm->tblName);
         pstSavm->m_lErrno = MALLC_MEM_ERR;
@@ -11036,7 +11171,7 @@ long    lMountTable(SATvm *pstSavm, char *pszFile)
     }
 
     pstSavm->pstVoid = pvData;
-    pstSavm->lSize   = stTde.m_lReSize;
+    pstSavm->lSize   = sf.m_lReSize;
     prwLock = (RWLock *)pGetRWLock(pstRun->m_pvAddr);
     if(RC_SUCC != pthread_rwlock_wrlock(prwLock))
     {
@@ -11045,10 +11180,10 @@ long    lMountTable(SATvm *pstSavm, char *pszFile)
         goto MOUNT_ERROR;
     }
 
-    while(1 == fread(pvData, stTde.m_lReSize, 1, fp))
+    while(1 == fread(pvData, sf.m_lReSize, 1, fp))
     {
         fread((void *)&uTimes, sizeof(ulong), 1, fp);
-        if(lGetTblRow(stTde.m_table) <= ((TblDef *)pstRun->m_pvAddr)->m_lValid)
+        if(lGetTblRow(sf.m_table) <= ((TblDef *)pstRun->m_pvAddr)->m_lValid)
         {
             pthread_rwlock_unlock(prwLock);
             vTblDisconnect(pstSavm, pstSavm->tblName);
@@ -11060,7 +11195,7 @@ long    lMountTable(SATvm *pstSavm, char *pszFile)
         if(RC_SUCC != __lInsert(pstSavm, pstRun, pstSavm->tblName, uTimes))
         {
             fprintf(stderr, "=>警告, 导入表:%s 第(%ld)条记录错误, %s, 跳过..\n", 
-                sGetTableName(stTde.m_table), lEffect, sGetTError(pstSavm->m_lErrno));
+                sGetTableName(sf.m_table), lEffect, sGetTError(pstSavm->m_lErrno));
             continue;
         }
 
@@ -11072,7 +11207,7 @@ long    lMountTable(SATvm *pstSavm, char *pszFile)
     vTblDisconnect(pstSavm, pstSavm->tblName);
 
     fprintf(stdout, "导入表:%s 有效记录:%ld, completed successfully !!\n", 
-        sGetTableName(stTde.m_table), lEffect);
+        sGetTableName(sf.m_table), lEffect);
     return RC_SUCC;
 
 MOUNT_ERROR: