transactd 3.5.0 → 3.6.0

data/source/bzs/db/engine/mysql/database.cpp

@@ -244,22 +244,24 @@ unsigned char* database::getUserSha1Passwd(const char* host, const char* user,
 	        tb = useTable(tb2->id(), SQLCOM_SELECT, NULL);
 	        if (tb)
 	        {
-	            tb->setKeyNum((char)0);
-	            std::vector<std::string> keyValues;
-	            keyValues.push_back(host);
-	            keyValues.push_back(user);
-	            tb->setKeyValues(keyValues, -1, NULL);
-	            tb->seekKey(HA_READ_KEY_EXACT, tb->keymap());
-	            if (tb->stat() == 0)
-	            {
-	                int size;
-	                const char* p =  tb->valStr(MYSQL_USER_FIELD_PASSWORD, size);
-	                if (strlen(p))
-	                {
-	                    get_salt_from_password(buf, p);
-	                    retPtr = buf;
-	                }
-	            }
+                if (tb->setKeyNum((char)0))
+                {
+                    std::vector<std::string> keyValues;
+                    keyValues.push_back(host);
+                    keyValues.push_back(user);
+                    tb->setKeyValues(keyValues, -1, NULL);
+                    tb->seekKey(HA_READ_KEY_EXACT, tb->keymap());
+                    if (tb->stat() == 0)
+                    {
+                        int size;
+                        const char* p = tb->valStr(MYSQL_USER_FIELD_PASSWORD, size);
+                        if (strlen(p))
+                        {
+                            get_salt_from_password(buf, p);
+                            retPtr = buf;
+                        }
+                    }
+                }
 	            tb->unUse();
 	        }
             closeTable(tb2);
@@ -541,7 +543,7 @@ table* database::useTable(int index, enum_sql_command cmd, rowLockMode* lck)
     }
     if (tb->isExclusveMode())
         m_thd->variables.option_bits &= ~OPTION_TABLE_LOCK;
-    
+    /* A orver head of init_table_handle_for_HANDLER is a small */
     tb->initForHANDLER();
     tb->setLocked(true);
     m_thd->in_lock_tables = 0;
@@ -1032,6 +1034,19 @@ unsigned short nisFieldNum(TABLE* tb)
     return 0;
 }
 
+/* class prepareHandler */
+void prepareHandler::setInnodbFetchExtraCols(unsigned long v)
+{
+    if (m_innodb)
+    {
+        innodb_prebuit* prebuilt = *((innodb_prebuit**)((char*)(m_table->file) + sizeof(handler)+DSMRR_SIZE));
+        if (prebuilt->magic_n == ROW_PREBUILT_ALLOCATED && prebuilt->hint_need_to_fetch_extra_cols <= ROW_RETRIEVE_ALL_COLS)
+            prebuilt->hint_need_to_fetch_extra_cols = v;
+        else
+            THROW_BZS_ERROR_WITH_CODEMSG(STATUS_PROGRAM_ERROR, "Cast error for Innodb prebuilt.");
+    }
+}
+
 bool table::noKeybufResult = true;
 
 table::table(TABLE* myTable, database& db, const std::string& name, short mode,
@@ -1039,16 +1054,14 @@ table::table(TABLE* myTable, database& db, const std::string& name, short mode,
     : m_table(myTable), m_name(name), m_mode(mode), m_id(id), m_db(db),
       m_keybuf(new unsigned char[MAX_KEYLEN]),
       m_stat(0),
-      m_keyconv(m_table->key_info, m_table->s->keys), m_blobBuffer(NULL), 
+      m_keyconv(m_table->key_info, m_table->s->keys), m_blobBuffer(NULL),m_updateAtField(NULL), 
       m_readCount(0), m_updCount(0), m_delCount(0), m_insCount(0), m_privilege(0xFFFF),
-      m_keyNum(-1), m_nonNcc(false), m_validCursor(true), m_cursor(false), 
+      m_nonNcc(false), m_validCursor(true), m_cursor(false), 
       m_locked(false), m_changed(false), m_nounlock(false), m_bulkInserting(false),
       m_delayAutoCommit(false),m_forceConsistentRead(false), m_mysqlNull(mysqlnull),
-      m_timestampAlways(g_timestamp_always != 0)
+      m_timestampAlways(g_timestamp_always != 0), m_prepare(myTable)
 {
 
-    m_table->read_set = &m_table->s->all_set;
-
     m_recordFormatType = RF_VALIABLE_LEN;
 #ifdef USE_BTRV_VARIABLE_LEN
     m_lastVarLenBytes = 0;
@@ -1093,6 +1106,10 @@ table::table(TABLE* myTable, database& db, const std::string& name, short mode,
                 fd->unireg_check == Field::TIMESTAMP_DNUN_FIELD ||
                 fd->unireg_check == Field::TIMESTAMP_DN_FIELD)
             m_timeStampFields.push_back(fd);
+        if (m_updateAtField == NULL && 
+                (fd->unireg_check == Field::TIMESTAMP_UN_FIELD ||
+                 fd->unireg_check == Field::TIMESTAMP_DNUN_FIELD))
+            m_updateAtField = fd;
     }
     m_nullBytesCl = (nullbits + 7) / 8; 
 
@@ -1144,7 +1161,7 @@ void table::resetInternalTable(TABLE* table)
     else
     {
         m_table = table;
-        m_table->read_set = &m_table->s->all_set;
+        m_prepare.init(table);
         m_locked = false;
         m_changed = false;
         m_validCursor = false;
@@ -1171,39 +1188,33 @@ void table::checkACL(enum_sql_command cmd)
     }
 }
 
-bool table::setNonKey(bool scan)
+bool table::setNonKey(bool wholeRow, bool keyRead)
 {
-    if (m_keyNum != -2)
-    {
-        m_table->file->ha_index_or_rnd_end();
-        int ret = m_table->file->ha_rnd_init(scan);
-        if (ret)
-            THROW_BZS_ERROR_WITH_CODEMSG(ERROR_INDEX_RND_INIT,
-                                         "setNonKey rnd_init error.");
-        m_keyNum = -2;
-    }
+    m_prepare.setKeyNum(-2);
+    m_prepare.ready(wholeRow, keyRead);
     return true;
 }
 
-bool table::setKeyNum(char num, bool sorted)
+bool table::setKeyNum(char num, bool wholeRow, bool keyRead)
 {
-    if (num < 0)
+    if (!keynumCheck(num))
     {
         m_stat = STATUS_INVALID_KEYNUM;
         return false;
     }
-    if ((m_keyNum != num) ||
-        ((m_keyNum >= 0) && (m_table->file->inited == handler::NONE)))
+    m_prepare.setKeyNum(num);
+    m_prepare.ready(wholeRow, keyRead);
+    return true;
+}
+
+bool table::setKeyNumForMultiRead(char num)
+{
+    if (num != -2 && !keynumCheck(num))
     {
-        m_table->file->ha_index_or_rnd_end();
-        if (!keynumCheck(num))
-        {
-            m_stat = STATUS_INVALID_KEYNUM;
-            return false;
-        }
-        m_keyNum = num;
-        m_table->file->ha_index_init(m_keyNum, sorted);
+        m_stat = STATUS_INVALID_KEYNUM;
+        return false;
     }
+    m_prepare.setKeyNum(num);
     return true;
 }
 
@@ -1221,7 +1232,7 @@ void table::fillNull(uchar* ptr, int size)
 
 void table::setKeyValues(const uchar* ptr, int size)
 {
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     memcpy(&m_keybuf[0], ptr, std::min(MAX_KEYLEN, size));
     int pos = 0;
     for (int j = 0; j < (int)key.user_defined_key_parts; j++)
@@ -1251,7 +1262,7 @@ void table::setKeyValues(const uchar* ptr, int size)
  */
 short table::setKeyValuesPacked(const uchar* ptr, int size)
 {
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     int to = 0;
     const uchar* from = ptr;
     int ret = -1;
@@ -1308,10 +1319,10 @@ short table::setKeyValuesPacked(const uchar* ptr, int size)
 uint table::keyPackCopy(uchar* ptr)
 {
     // if nokey and getbookmark operation then keynum = -2
-    if (m_keyNum < 0)
+    if (keyNum() < 0)
         return 0;
 
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     if ((key.flags & HA_NULL_PART_KEY) || (key.flags & HA_VAR_LENGTH_KEY))
     {
         int from = 0;
@@ -1350,20 +1361,13 @@ void* table::record() const
   �@m_recordFormatType=RF_FIXED_PLUS_VALIABLE_LEN.
     ptr is excluding null flag sgement.
  */
-void table::setRecord(void* ptr, unsigned short size, int offset)
+void table::setRecord(void* ptr, unsigned short size, int offset, 
+            bzs::db::protocol::tdap::autoIncPackInfo* ai)
 {
     m_cursor = false;
     unsigned char* p;
-    /*if (m_mysqlNull && m_table->s->null_fields)
-    {
-        p = m_table->record[0];
-        size = std::min(size, (unsigned short)recordLen());
-    }
-    else*/
-    {
-        p = (unsigned char*)record();
-        size = std::min(size, (unsigned short)recordLenCl());
-    }
+    p = (unsigned char*)record();
+    size = std::min(size, (unsigned short)recordLenCl());
 #ifdef USE_BTRV_VARIABLE_LEN
     if (offset + size <=
         (unsigned short)m_table->s->reclength + lastVarLenBytes())
@@ -1379,6 +1383,11 @@ void table::setRecord(void* ptr, unsigned short size, int offset)
     }
     else
         THROW_BZS_ERROR_WITH_CODEMSG(STATUS_INVALID_DATASIZE, "");
+    if (ai && m_table->next_number_field)
+    {
+        ai->pos = (unsigned short)(m_table->next_number_field->ptr - m_table->field[0]->ptr);
+        ai->len =  m_table->next_number_field->pack_length();
+    }
 }
 
 inline bool isNullValue(Field* fd)
@@ -1428,7 +1437,6 @@ inline bool isNullNis(KEY& key, bool all)
 
 void table::setBlobFieldPointer(const bzs::db::blobHeader* hd)
 {
-
     if (hd)
     {
         assert(hd->curRow < hd->rows);
@@ -1450,7 +1458,8 @@ void table::setBlobFieldPointer(const bzs::db::blobHeader* hd)
 /** A packed data set to the record buffer.
  */
 void table::setRecordFromPacked(const uchar* packedPtr, uint size,
-                                const bzs::db::blobHeader* hd)
+                                const bzs::db::blobHeader* hd, 
+                                bzs::db::protocol::tdap::autoIncPackInfo* ai)
 {
     const uchar* p = packedPtr;
     bool nullable = (m_mysqlNull && m_table->s->null_fields);
@@ -1464,10 +1473,10 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
                            (int)recordLenCl() - varlenStartPos);
         if (len > 0)
         {
-            setRecord(&len, varlenbyte, varlenStartPos);
+            setRecord(&len, varlenbyte, varlenStartPos, ai);
             // if (len > 0)
             setRecord((void*)(p + varlenStartPos), len,
-                      varlenStartPos + varlenbyte);
+                      varlenStartPos + varlenbyte, ai);
         }
         else if (len == 0)
             ;
@@ -1494,6 +1503,12 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
         for (uint i = 0; i < m_table->s->fields; ++i)
         {
             Field* fd = m_table->field[i];
+            if (ai && (fd->flags & AUTO_INCREMENT_FLAG))
+            {
+                ai->pos =  (unsigned short)(p - packedPtr);
+                ai->len =  fd->pack_length();
+            }
+
             bool isNull = false;
             if (fd->null_bit && nullable)
             {
@@ -1538,7 +1553,7 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
             setBlobFieldPointer(hd);
     }
     else
-        setRecord((void*)p, size);
+        setRecord((void*)p, size, 0, ai);
 }
 
 /** A record image is packed, and is copied to the specified buffer, and length
@@ -1583,9 +1598,10 @@ uint table::recordPackCopy(char* buf, uint maxsize)
     {
 #endif
         int blobs = 0;
+        if (m_nullBytesCl)
+            memset(buf, 0, m_nullBytesCl);
         p = buf + m_nullBytesCl;
         unsigned char* null_ptr = (unsigned char*)buf;//m_table->record[0];
-        *null_ptr = 0x00;
         unsigned char null_bit = 1; 
         for (uint i = 0; i < m_table->s->fields; i++)
         {
@@ -1596,11 +1612,7 @@ uint table::recordPackCopy(char* buf, uint maxsize)
                 //copy null bit
                 isNull = fd->is_null();
                 if (isNull)
-                {
-                    if (null_bit == 1)
-                        *null_ptr = 0x00;
                     *null_ptr |= null_bit;
-                }
                 if (null_bit == (uchar)128)
                 {
                     ++null_ptr;
@@ -1695,21 +1707,16 @@ inline void table::unlockRow(bool noConsistent)
 void table::seekKey(enum ha_rkey_function find_flag, key_part_map keyMap)
 {
     m_nonNcc = false;
-    if (keynumCheck(m_keyNum))
+    unlockRow(m_delayAutoCommit);
+    m_stat = m_table->file->ha_index_read_map(
+        m_table->record[0], &m_keybuf[0], keyMap /* keymap() */, find_flag);
+    setCursorStaus();
+    if (m_stat == 0)
     {
-        unlockRow(m_delayAutoCommit);
-        m_stat = m_table->file->ha_index_read_map(
-            m_table->record[0], &m_keybuf[0], keyMap /* keymap() */, find_flag);
-        setCursorStaus();
-        if (m_stat == 0)
-        {
-            if (find_flag != HA_READ_KEY_EXACT)
-                key_copy(&m_keybuf[0], m_table->record[0],
-                         &m_table->key_info[(int)m_keyNum], KEYLEN_ALLCOPY);
-        }
+        if (find_flag != HA_READ_KEY_EXACT)
+            key_copy(&m_keybuf[0], m_table->record[0],
+                     &m_table->key_info[(int)keyNum()], KEYLEN_ALLCOPY);
     }
-    else
-        m_stat = STATUS_INVALID_KEYNUM;
     if ((m_stat == HA_ERR_KEY_NOT_FOUND) && (find_flag != HA_READ_KEY_EXACT))
         m_stat = HA_ERR_END_OF_FILE;
 }
@@ -1717,7 +1724,7 @@ void table::seekKey(enum ha_rkey_function find_flag, key_part_map keyMap)
 void table::moveKey(boost::function<int()> func)
 {
     m_nonNcc = false;
-    if (keynumCheck(m_keyNum))
+    if (keynumCheck(keyNum()))
     {
         unlockRow(m_delayAutoCommit);
 
@@ -1725,7 +1732,7 @@ void table::moveKey(boost::function<int()> func)
         setCursorStaus();
         if (m_stat == 0)
             key_copy(&m_keybuf[0], m_table->record[0],
-                     &m_table->key_info[(int)m_keyNum], KEYLEN_ALLCOPY);
+                     &m_table->key_info[(int)keyNum()], KEYLEN_ALLCOPY);
     }
     else
         m_stat = STATUS_INVALID_KEYNUM;
@@ -1736,20 +1743,15 @@ void table::moveKey(boost::function<int()> func)
 void table::getNextSame(key_part_map keyMap)
 {
     m_nonNcc = false;
-    if (keynumCheck(m_keyNum))
+    unlockRow(false /*lock*/);
+    m_stat = m_table->file->ha_index_next_same(
+        m_table->record[0], &m_keybuf[0], keyMap /* keymap() */);
+    setCursorStaus();
+    if (m_stat == 0)
     {
-        unlockRow(false /*lock*/);
-        m_stat = m_table->file->ha_index_next_same(
-            m_table->record[0], &m_keybuf[0], keyMap /* keymap() */);
-        setCursorStaus();
-        if (m_stat == 0)
-        {
-            key_copy(&m_keybuf[0], m_table->record[0],
-                     &m_table->key_info[(int)m_keyNum], KEYLEN_ALLCOPY);
-        }
+        key_copy(&m_keybuf[0], m_table->record[0],
+                 &m_table->key_info[(int)keyNum()], KEYLEN_ALLCOPY);
     }
-    else
-        m_stat = STATUS_INVALID_KEYNUM;
 }
 
 void table::getLast()
@@ -1790,7 +1792,7 @@ void table::getNext()
     if (m_nonNcc)
     { // It moves to the position after updating.
         // Since it may be lost, ref is compared and the next is decided.
-        movePos(position(true), m_keyNum, true);
+        movePos(position(true), keyNum(), true);
         if (m_stat)
             return;
     }
@@ -1807,7 +1809,7 @@ void table::getPrev()
     }
     if (m_nonNcc)
     {
-        movePos(position(true), m_keyNum, true);
+        movePos(position(true), keyNum(), true);
         if (m_stat)
             return;
     }
@@ -1817,10 +1819,10 @@ void table::getPrev()
 
 bool table::keyCheckForPercent()
 {
-    if (m_keyNum == -1)
-        m_keyNum = m_table->s->primary_key;
+    if (keyNum() == -1)
+        setKeyNum(m_table->s->primary_key);
     // The value of the beginning of a key
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     if (key.key_length > 128)
         return false;
     return true;
@@ -1828,7 +1830,7 @@ bool table::keyCheckForPercent()
 
 void table::preBuildPercent(uchar* first, uchar* last)
 {
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     getFirst();
     if (m_stat == 0)
     {
@@ -1878,7 +1880,7 @@ void table::getByPercentage(unsigned short per)
         uchar* st = keybufFirst;
         uchar* en = keybufLast;
         uchar* cu = (uchar*)keybuf();
-        KEY& key = m_table->key_info[(int)m_keyNum];
+        KEY& key = m_table->key_info[(int)keyNum()];
         uint keylen = key.key_length + 10;
         boost::shared_array<uchar> stbuf(new uchar[keylen]);
         boost::shared_array<uchar> lsbuf(new uchar[keylen]);
@@ -1966,7 +1968,7 @@ void table::getByPercentage(unsigned short per)
 
 int table::percentage(uchar* first, uchar* last, uchar* cur)
 {
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     // 1 cur to last
     key_range minkey;
     minkey.key = cur;
@@ -1975,11 +1977,11 @@ int table::percentage(uchar* first, uchar* last, uchar* cur)
     minkey.flag = HA_READ_KEY_EXACT;
     key_range maxkey = minkey;
     maxkey.key = last;
-    ha_rows rows1 = m_table->file->records_in_range(m_keyNum, &minkey, &maxkey);
+    ha_rows rows1 = m_table->file->records_in_range(keyNum(), &minkey, &maxkey);
 
     // 2 first to last
     maxkey.key = first;
-    ha_rows rows2 = m_table->file->records_in_range(m_keyNum, &maxkey, &minkey);
+    ha_rows rows2 = m_table->file->records_in_range(keyNum(), &maxkey, &minkey);
 
     // 3 record count
     ha_rows total = recordCount(true);
@@ -2003,7 +2005,7 @@ void table::calcPercentage()
     m_percentResult = 0;
     // The present key value is copied.
     uchar keybufCur[MAX_KEYLEN] = { 0x00 };
-    key_copy(keybufCur, m_table->record[0], &m_table->key_info[(int)m_keyNum],
+    key_copy(keybufCur, m_table->record[0], &m_table->key_info[(int)keyNum()],
              KEYLEN_ALLCOPY);
 
     uchar keybufFirst[MAX_KEYLEN] = { 0x00 };
@@ -2028,8 +2030,7 @@ void table::stepFirst()
     }
     else
     {
-        m_keyNum = -1;
-        if (setNonKey(true))
+        if (setNonKey())
         {
             unlockRow(m_delayAutoCommit);
             m_stat = m_table->file->ha_rnd_next(m_table->record[0]);
@@ -2061,9 +2062,9 @@ void table::stepNext()
     }
     else
     {
-        if (m_keyNum != -2)
+        if (keyNum() != -2)
         {
-            if (setNonKey(false))
+            if (setNonKey())
             {
                 unlockRow(false/*lock*/);
                 m_stat = m_table->file->ha_rnd_pos(m_table->record[0],
@@ -2130,11 +2131,12 @@ void table::readRecords(IReadRecordsHandler* hdr, bool includeCurrent, int type,
             case READ_RECORD_STEPNEXT:
                 m_stat = m_table->file->ha_rnd_next(m_table->record[0]);break;
             default: //READ_RECORD_STEPPREV
-                setCursorStaus();
+                setCursorStaus(true);
                 m_stat = STATUS_NOSUPPORT_OP;
                 return;
             }
-            //setCursorStaus();
+            if (m_stat == 0)
+                ++m_readCount;
         }
         else
             read = true;
@@ -2159,7 +2161,7 @@ void table::readRecords(IReadRecordsHandler* hdr, bool includeCurrent, int type,
                 
             if (ret == REC_NOMACTH_NOMORE)
             {
-                setCursorStaus();
+                setCursorStaus(true);
                 m_stat = STATUS_REACHED_FILTER_COND;
                 return;
             }
@@ -2167,7 +2169,7 @@ void table::readRecords(IReadRecordsHandler* hdr, bool includeCurrent, int type,
                 --reject;
         }
     }
-    setCursorStaus();
+    setCursorStaus(true);
     m_stat = tmp_stat;
     if (reject == 0)
         m_stat = STATUS_LIMMIT_OF_REJECT;
@@ -2180,7 +2182,7 @@ void table::readRecords(IReadRecordsHandler* hdr, bool includeCurrent, int type,
 void table::seekPos(const uchar* rawPos)
 {
     seekKey(HA_READ_KEY_OR_NEXT, keymap());
-    if (m_keyNum == (int)m_table->s->primary_key)
+    if (keyNum() == (int)m_table->s->primary_key)
         return;
     int cmp;
     while ((m_stat == 0) &&
@@ -2192,28 +2194,30 @@ void table::seekPos(const uchar* rawPos)
     }
 }
 
-void table::movePos(const uchar* pos, char keyNum, bool sureRawValue)
+/* move by ref and change key */
+void table::movePos(const uchar* pos, char keynum, bool sureRawValue)
 {
     const uchar* rawPos = pos;
     if (!sureRawValue && (m_table->file->ref_length > REF_SIZE_MAX))
         rawPos = bms()->getRefByBm(*(unsigned int*)pos);
 
-    setNonKey();
     unlockRow(m_delayAutoCommit);
+    setNonKey();
+
     m_stat = m_table->file->ha_rnd_pos(m_table->record[0], (uchar*)rawPos);
     setCursorStaus();
-    if ((keyNum == -1) || (keyNum == -64) || (keyNum == -2))
+    if ((keynum == -1) || (keynum == -64) || (keynum == -2))
         return;
     if (m_stat == 0)
     {
-        if (m_keyNum != keyNum)
+        if (keyNum() != keynum)
         { // need key change
             key_copy(&m_keybuf[0], m_table->record[0],
-                     &m_table->key_info[(int)keyNum], KEYLEN_ALLCOPY);
+                &m_table->key_info[(int)keynum], KEYLEN_ALLCOPY);
             // It seek(s) until ref becomes the same, since it is a duplication
             // key.
-            setKeyNum(keyNum);
-            seekPos(rawPos);
+            if (setKeyNum(keynum))
+                seekPos(rawPos);
         }
     }
 }
@@ -2266,12 +2270,10 @@ ha_rows table::recordCount(bool estimate)
     }
 	
     uint n = 0;
-    fieldBitmap fb(m_table);
-    char keynum = m_keyNum;
-    int inited = m_table->file->inited;
-    m_table->file->ha_index_or_rnd_end();
-    fb.setKeyRead(true);
-    if (setKeyNum((char)0, false /* sorted */))
+    char keynum = keyNum();
+
+    /* force change keynumber */
+    if (setKeyNum(primarykeyNum(), whole_row, key_read))
     {
         m_table->file->try_semi_consistent_read(true);
         m_stat = m_table->file->ha_index_first(m_table->record[0]);
@@ -2282,17 +2284,10 @@ ha_rows table::recordCount(bool estimate)
             ++m_readCount;
             m_stat = m_table->file->ha_index_next(m_table->record[0]);
         }
-        fb.setKeyRead(false);
-
-        // restore index init
-        if ((inited == (int)handler::INDEX) && (m_keyNum != keynum))
-            setKeyNum(keynum);
-        else if (inited == (int)handler::RND)
-            setNonKey(true /* scan */);
     }
     else
     {
-        setNonKey(true /* scan */);
+        setNonKey(whole_row, key_read);
         m_table->file->try_semi_consistent_read(true);
         m_stat = m_table->file->ha_rnd_next(m_table->record[0]);
         while (m_stat == 0)
@@ -2303,6 +2298,9 @@ ha_rows table::recordCount(bool estimate)
             m_stat = m_table->file->ha_rnd_next(m_table->record[0]);
         }
     }
+    // restore keynumber 
+    m_prepare.setKeyNum(keynum);
+
     return n;
 }
 
@@ -2370,7 +2368,7 @@ int table::setKeyNullFlags()
             if (key.flags & HA_NULL_PART_KEY)
             {
                 bool nullKey = setNullIf(key, m_mysqlNull);
-                if (nullKey && (i == m_keyNum))
+                if (nullKey && (i == keyNum()))
                     ++setCount;
             }
         }
@@ -2450,7 +2448,7 @@ __int64 table::insert(bool ncc)
         m_nonNcc = !ncc;
         if (!ncc && !m_bulkInserting)
             key_copy(&m_keybuf[0], m_table->record[0],
-                     &m_table->key_info[(int)m_keyNum], KEYLEN_ALLCOPY);
+                     &m_table->key_info[(int)keyNum()], KEYLEN_ALLCOPY);
         
         /* Do not change to m_changed = false */
         m_changed = true;
@@ -2459,71 +2457,83 @@ __int64 table::insert(bool ncc)
     return autoincValue;
 }
 
-void table::beginUpdate(char keyNum)
+/**
+    @return value of update_at 
+*/
+double table::beginUpdate(char keyNum, int confrictCheck)
 {
     m_stat = 0;
-    beginDel();
+    double v = beginDel(confrictCheck);
     if (m_stat == 0)
     {
         if (keyNum >= 0)
-           setKeyNum(keyNum);
+            setKeyNum(keyNum);
         store_record(m_table, record[1]);
     }
+    return v;
 }
-void table::beginDel()
+
+double table::beginDel(int confrictCheck)
 {
+    double v = 0;
     if ((m_mode == TD_OPEN_READONLY) || (m_table->reginfo.lock_type < TL_WRITE))
     {
         m_stat = STATUS_INVALID_LOCKTYPE;
-        return;
+        return v;
     }
-
-    if (m_db.m_inAutoTransaction == this)
+    if (!m_cursor)
     {
-        // Confirmed that hold lock(X) by innodb_lock_monitor
-        indexInit();
+        m_stat = STATUS_NO_CURRENT;
+        return v;
     }
 
-    if (m_cursor)
+    m_stat = 0;
+    /* The current position is established in advance.
+        If not in transaction then m_validCursor=false */
+    if (m_validCursor == false || confrictCheck == 1)
     {
-        m_stat = 0;
-        /* The current position is established in advance.
-         If not in transaction then m_validCursor=false */
-        if (m_validCursor == false)
+        store_record(m_table, record[1]);
+        if (keyNum() >= 0)
         {
-            store_record(m_table, record[1]);
-            if (m_keyNum >= 0)
-            {
-                // seek until ref is same.
-                uchar rawPos[128];
-                memcpy(rawPos, position(true), m_table->file->ref_length);
-                seekPos(rawPos);
-            }
-            else
-                movePos(position(true), -1, true);
+            // seek until ref is same.
+            uchar rawPos[128];
+            memcpy(rawPos, position(true), m_table->file->ref_length);
+            seekPos(rawPos);
+        }
+        else
+            movePos(position(true), -1, true);
 
-            // Has blob fields then ignore conflicts.
-            if ((m_stat == 0) && (m_table->s->blob_fields == 0) &&
-                cmp_record(m_table, record[1]))
-                m_stat = STATUS_CHANGE_CONFLICT;
+        // Has blob fields then ignore conflicts.
+        if ((m_stat == 0) && (m_table->s->blob_fields == 0) &&
+            cmp_record(m_table, record[1]))
+            m_stat = STATUS_CHANGE_CONFLICT;
 
-            setCursorStaus();
-            if (m_stat)
-                return;
-        }
-    }
-    else
-        m_stat = STATUS_NO_CURRENT;
+        setCursorStaus();
+        if (m_stat) return v;
+    }        
+
+    if (m_updateAtField && confrictCheck)
+        v = m_updateAtField->val_real();   
+
+    return v;
 }
 
 /** Update current record.
  *  It is indispensable that there is a current record in advance
  *  and beginUpdate() is called.
  */
-void table::update(bool ncc)
+void table::update(bool ncc, double updateAtBefore)
 {
     if (m_stat == 0)
     {
+        if (updateAtBefore != 0)
+        {
+            if(updateAtBefore != m_updateAtField->val_real())
+            {
+                m_stat = STATUS_CHANGE_CONFLICT;
+                return;
+            }
+        }
         int nullFieldsOfCurrentKey = setKeyNullFlags();
         if (!m_mysqlNull) setFieldNullFlags();
 		setTimeStamp(false /* update */);
@@ -2538,9 +2548,9 @@ void table::update(bool ncc)
             if (!ncc) // innodb default is ncc=-1.
             {
                 // Only when the present key value is changed
-                if (m_keyNum >= 0)
+                if (keyNum() >= 0)
                 {
-                    const KEY& key = m_table->key_info[(int)m_keyNum];
+                    const KEY& key = m_table->key_info[(int)keyNum()];
                     key_copy(&m_keybuf[0], m_table->record[0], (KEY*)&key,
                              KEYLEN_ALLCOPY);
 
@@ -2561,14 +2571,28 @@ void table::update(bool ncc)
     }
 }
 
+void table::setUpdateTimeValue(void* data)
+{
+    if (m_updateAtField)
+        memcpy(m_updateAtField->ptr, data, m_updateAtField->pack_length());
+}
+
 /** del current record.
  *  It is indispensable that there is a current record in advance
  *  and beginDel() is called.
  */
-void table::del()
+void table::del(double updateAtBefore)
 {
     if (m_stat == 0)
     {
+        if (updateAtBefore != 0)
+        {
+            if(updateAtBefore != m_updateAtField->val_real())
+            {
+                m_stat = STATUS_CHANGE_CONFLICT;
+                return;
+            }
+        }
         m_stat = m_table->file->ha_delete_row(m_table->record[0]);
         /* Do not change to m_changed = false */
         if (m_stat == 0)
@@ -2645,8 +2669,8 @@ void table::endBulkInsert()
 {
     if (m_bulkInserting)
     {
-		if (m_keyNum >= 0 && m_keyNum < (char)m_table->s->keys)
-			key_copy(&m_keybuf[0], m_table->record[0], &m_table->key_info[(int)m_keyNum],
+		if (keyNum() >= 0 && keyNum() < (char)m_table->s->keys)
+			key_copy(&m_keybuf[0], m_table->record[0], &m_table->key_info[(int)keyNum()],
 					KEYLEN_ALLCOPY);
         m_bulkInserting = false;
         m_table->file->ha_release_auto_increment();
@@ -2680,7 +2704,7 @@ inline void setSegmentValue(const KEY_PART_INFO& segment, const std::string& v)
 void table::setKeyValues(const std::vector<std::string>& values, int keypart,
                          const std::string* inValue)
 {
-    KEY& key = m_table->key_info[(int)m_keyNum];
+    KEY& key = m_table->key_info[(int)keyNum()];
     for (int i = 0; i < (int)key.user_defined_key_parts; i++)
         if (i < (int)values.size())
             setSegmentValue(key.key_part[i], values[i]);
@@ -2713,9 +2737,11 @@ unsigned int table::writeDefaultImage(unsigned char* p, size_t size)
     return len + sizeof(unsigned short);
 }
 
-unsigned int table::writeSchemaImage(unsigned char* p, size_t size)
+unsigned int table::writeSchemaImage(unsigned char* p, size_t size, bool bin_str)
 {
-    protocol::tdap::tabledef* td = schemaBuilder().getTabledef(this, 0, m_mysqlNull, p + 2, size - 2);
+    unsigned char bin_char_index = bin_str ? 0 : CHARSET_BIN;
+
+    protocol::tdap::tabledef* td = schemaBuilder(bin_char_index).getTabledef(this, 0, m_mysqlNull, p + 2, size - 2);
     unsigned short len = 0;
     if (td)
         len = td->varSize + 4;