transactd 2.4.5 → 3.0.0

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

@@ -26,6 +26,10 @@
 #include "bookmark.h"
 #include <bzs/rtl/stl_uty.h>
 #include <boost/shared_array.hpp>
+#include <bzs/db/protocol/tdap/mysql/databaseSchema.h>
+
+
+extern unsigned int g_timestamp_always;
 
 namespace bzs
 {
@@ -186,11 +190,11 @@ bool unlockTables(bool releaseStatementLock, THD* thd, bool rollback, database::
 tableCacheCounter database::tableRef;
 
 database::database(const char* name, short cid)
-    : m_dbname(name), m_thd(createThdForThread()), 
-      m_inTransaction(0), m_inSnapshot(0), m_stat(0), m_usingExclusive(false),
-      m_inAutoTransaction(NULL), m_trnType(0), m_cid(cid), m_privilege(0xFFFF)
+    : m_dbname(name), m_thd(createThdForThread()),m_inAutoTransaction(NULL), 
+       m_privilege(0xFFFF), m_inTransaction(0), m_inSnapshot(0), m_stat(0),
+       m_usingExclusive(false), m_trnType(0), m_cid(cid)
 {
-	cp_security_ctx(m_thd)->skip_grants();
+    cp_security_ctx(m_thd)->skip_grants();
 }
 
 #ifdef _MSC_VER
@@ -770,11 +774,14 @@ table* database::openTable(const std::string& name, short mode,
         m_stat = STATUS_ALREADY_INTRANSACTION;
         return NULL;
     }
+    bool mysql_null = IS_MODE_MYSQL_NULL(mode);
+    if (mysql_null)
+        mode -= TD_OPEN_MASK_MYSQL_NULL; 
     TABLE* t = doOpenTable(name, mode, ownerName);
     if (t)
     {
         boost::shared_ptr<table> tb(
-            new table(t, *this, name, mode, (int)m_tables.size()));
+            new table(t, *this, name, mode, (int)m_tables.size(), mysql_null));
         {
             boost::mutex::scoped_lock lck(tableRef.mutex());
             m_tables.push_back(tb);
@@ -929,7 +936,7 @@ unsigned short nisFieldNum(TABLE* tb)
 bool table::noKeybufResult = true;
 
 table::table(TABLE* myTable, database& db, const std::string& name, short mode,
-             int id)
+             int id, bool mysqlnull)
     : 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),
@@ -937,7 +944,8 @@ table::table(TABLE* myTable, database& db, const std::string& name, short mode,
       m_readCount(0), m_updCount(0), m_delCount(0), m_insCount(0),
       m_keyNum(-1), 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_delayAutoCommit(false),m_forceConsistentRead(false), m_mysqlNull(mysqlnull),
+      m_timestampAlways(g_timestamp_always != 0)
 {
 
     m_table->read_set = &m_table->s->all_set;
@@ -947,7 +955,7 @@ table::table(TABLE* myTable, database& db, const std::string& name, short mode,
     m_lastVarLenBytes = 0;
 #endif
     // Is the Nis field included or not?
-    m_nullFields = nisFieldNum(m_table);
+    m_nisNullFields = nisFieldNum(m_table);
 
     if (m_table->s->varchar_fields + m_table->s->blob_fields == 0)
         m_recordFormatType = RF_FIXED_LEN;
@@ -966,36 +974,41 @@ table::table(TABLE* myTable, database& db, const std::string& name, short mode,
         }
     }
 #endif
-    if (m_nullFields)
+    if (m_nisNullFields)
         m_recordFormatType |= RF_INCLUDE_NIS;
-#ifdef USE_BTRV_VARIABLE_LEN
-    m_recordLenCl = (uint)(m_table->s->reclength - m_table->s->null_bytes -
-                           m_nullFields - m_lastVarLenBytes);
-#else
-    m_recordLenCl =
-        (uint)(m_table->s->reclength - m_table->s->null_bytes - m_nullFields);
-#endif
-    // Chash null field
-    if (m_table->s->null_fields)
-    {
-        for (int i = 0; i < (int)m_table->s->fields; ++i)
-        {
-            Field* fd = m_table->field[i];
-            if (fd->null_bit && fd->part_of_key.is_clear_all())
-                m_nonKeySegNullFields.push_back(fd);
-        }
-    }
-    // Chash timestamp field
+
+    // Cache null fields ,timestamp fields and  no null mode null fields lists
+    int nullbits = 0;
     for (int i = 0; i < (int)m_table->s->fields; ++i)
     {
         Field* fd = m_table->field[i];
-        if (fd->unireg_check == Field::TIMESTAMP_UN_FIELD ||
-            fd->unireg_check == Field::TIMESTAMP_DNUN_FIELD ||
-            fd->unireg_check == Field::TIMESTAMP_DN_FIELD)
+        if (fd->null_bit)
         {
-            m_timeStampFields.push_back(fd);
+            if (m_mysqlNull)
+                ++nullbits;
+            else if (fd->part_of_key.is_clear_all())
+                m_noNullModeNullFieldList.push_back(fd);
         }
+
+        if (fd->unireg_check == Field::TIMESTAMP_UN_FIELD ||
+                fd->unireg_check == Field::TIMESTAMP_DNUN_FIELD ||
+                fd->unireg_check == Field::TIMESTAMP_DN_FIELD)
+            m_timeStampFields.push_back(fd);
     }
+    m_nullBytesCl = (nullbits + 7) / 8; 
+
+#ifdef USE_BTRV_VARIABLE_LEN
+    m_recordLenCl = (uint)(m_table->s->reclength - m_table->s->null_bytes -
+                           m_nisNullFields - m_lastVarLenBytes);
+#else
+    m_recordLenCl =
+        (uint)(m_table->s->reclength - m_table->s->null_bytes - m_nisNullFields);
+#endif
+    
+#if (MYSQL_VERSION_ID < 50600)
+    m_table->timestamp_field_type = TIMESTAMP_NO_AUTO_SET;
+#endif
+
 }
 
 table::~table()
@@ -1127,18 +1140,19 @@ short table::setKeyValuesPacked(const uchar* ptr, int size)
     for (int j = 0; j < (int)key.user_defined_key_parts; j++)
     {
         KEY_PART_INFO& seg = key.key_part[j];
-        if (seg.null_bit)
-        {
-            m_keybuf[to++] = 0x00;   // set null to mysql null indicator. 
-            seg.field->set_notnull();// Ignore null for read.
-        }
         if (seg.null_bit && isNisField(seg.field->field_name))
         {
-            m_keybuf[to++] = 0x00; // set null to nis field. 
+            m_keybuf[to++] = 0x00; // set not null to nis field.
+            m_keybuf[to++] = 0x00; // set value to nis field. 
             //continue next segment
         }
         else
         {
+            if (seg.null_bit)
+            {
+                m_keybuf[to++] = *from;
+                ++from;
+            }
             unsigned short copylen = seg.length; // length = store_len - varlen
             unsigned short copyspace = copylen;
             if (seg.key_part_flag & HA_BLOB_PART ||
@@ -1221,7 +1235,17 @@ void* table::record() const
 void table::setRecord(void* ptr, unsigned short size, int offset)
 {
     m_cursor = false;
-    Field* fd = m_table->field[0]; // remove null flag segment
+    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());
+    }
 #ifdef USE_BTRV_VARIABLE_LEN
     if (offset + size <=
         (unsigned short)m_table->s->reclength + lastVarLenBytes())
@@ -1233,13 +1257,13 @@ void table::setRecord(void* ptr, unsigned short size, int offset)
 #endif
 
         if (size > 0)
-            memcpy(fd->ptr + offset, ptr, size);
+            memcpy(p + offset, ptr, size);
     }
     else
         THROW_BZS_ERROR_WITH_CODEMSG(STATUS_INVALID_DATASIZE, "");
 }
 
-inline bool isNull(Field* fd)
+inline bool isNullValue(Field* fd)
 {
     if (isVarType(fd->type()))
     {
@@ -1271,7 +1295,7 @@ inline bool isNullNis(KEY& key, bool all)
         Field* fd = key.key_part[j].field;
         if (key.key_part[j].null_bit)
         {
-            bool v = isNull(fd);
+            bool v = isNullValue(fd);
             v ? fd->set_null() : fd->set_notnull();
             if (all && !v)
                 return false;
@@ -1311,7 +1335,7 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
                                 const bzs::db::blobHeader* hd)
 {
     const uchar* p = packedPtr;
-
+    bool nullable = (m_mysqlNull && m_table->s->null_fields);
 #ifdef USE_BTRV_VARIABLE_LEN
     if (recordFormatType() & RF_FIXED_PLUS_VALIABLE_LEN)
     {
@@ -1337,39 +1361,66 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
              (recordFormatType() & RF_INCLUDE_NIS))
     {
 #else
-    if ((recordFormatType() & RF_VALIABLE_LEN) ||
+    if (nullable || (recordFormatType() & RF_VALIABLE_LEN) ||
         (recordFormatType() & RF_INCLUDE_NIS))
     {
 #endif
+        //copy null bits
+        
+        
         // It copies for every field.
-        for (uint i = 0; i < m_table->s->fields; i++)
+        // But if null then not recived field image
+        unsigned char* null_ptr = (unsigned char*)p;
+        unsigned char null_bit = 1; 
+        p += m_nullBytesCl;
+        for (uint i = 0; i < m_table->s->fields; ++i)
         {
             Field* fd = m_table->field[i];
+            bool isNull = false;
+            if (fd->null_bit && nullable)
+            {
+                isNull = (*null_ptr & null_bit) != 0;
+                if (isNull)
+                    fd->set_null();
+                else
+                    fd->set_notnull();
+                if (null_bit == (uchar)128)
+                {
+                    ++null_ptr;
+                    null_bit = 1;
+                }else
+                    null_bit = null_bit << 1;
+            }
+
             if (isNisField(fd->field_name))
                 fd->ptr[0] = 0x00; // The Nis field is not sent from a client.
             else
             {
-                int len = fd->pack_length();
-                if (isVarType(fd->type()))
+                if (!isNull)
                 {
-                    len = var_total_len(p, var_bytes(fd));
-                    if (len > (int)fd->pack_length())
+                    int len = fd->pack_length();
+                    if (isVarType(fd->type()))
+                    {
+                        len = var_total_len(p, var_bytes(fd));
+                        if (len > (int)fd->pack_length())
+                            THROW_BZS_ERROR_WITH_CODEMSG(STATUS_BUFFERTOOSMALL,
+                                                            "setRecordFromPacked");
+                    }
+                    else if (size < (uint)len)
                         THROW_BZS_ERROR_WITH_CODEMSG(STATUS_BUFFERTOOSMALL,
-                                                     "setRecordFromPacked");
-                }
-                else if (size < (uint)len)
-                    THROW_BZS_ERROR_WITH_CODEMSG(STATUS_BUFFERTOOSMALL,
-                                                 "setRecordFromPacked");
-                memcpy(fd->ptr, p, len);
-                p += len;
-                size -= len;
+                                                        "setRecordFromPacked");
+                    memcpy(fd->ptr, p, len);
+                    p += len;
+                    size -= len;
+                }else
+                    memset(fd->ptr, 0, fd->pack_length());
             }
         }
         if (m_table->s->blob_fields)
             setBlobFieldPointer(hd);
     }
     else
-        setRecord((void*)p, std::min(size, recordLenCl()));
+        setRecord((void*)p, size);
 }
 
 /** A record image is packed, and is copied to the specified buffer, and length
@@ -1381,6 +1432,7 @@ void table::setRecordFromPacked(const uchar* packedPtr, uint size,
 uint table::recordPackCopy(char* buf, uint maxsize)
 {
     char* p = buf;
+    bool nullable = (m_mysqlNull && m_table->s->null_fields);
 #ifdef USE_BTRV_VARIABLE_LEN
     if (recordFormatType() & RF_FIXED_PLUS_VALIABLE_LEN)
     {
@@ -1408,18 +1460,40 @@ uint table::recordPackCopy(char* buf, uint maxsize)
              (recordFormatType() & RF_INCLUDE_NIS))
     {
 #else
-    if ((recordFormatType() & RF_VALIABLE_LEN) ||
+    if (nullable || (recordFormatType() & RF_VALIABLE_LEN) ||
         (recordFormatType() & RF_INCLUDE_NIS))
     {
 #endif
         int blobs = 0;
+        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++)
         {
             Field* fd = m_table->field[i];
+            bool isNull = false;
+            if (fd->null_bit && nullable)
+            {
+                //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;
+                    null_bit = 1;
+                }else
+                    null_bit = null_bit << 1;
+            }
             if (isNisField(fd->field_name))
                 ;
             // The Nis field is not sent to a client.
-            else
+            else if (!isNull)
             {
                 uint len = fd->pack_length();
                 if (isVarType(fd->type()))
@@ -1447,7 +1521,7 @@ uint table::recordPackCopy(char* buf, uint maxsize)
     return (uint)(p - buf);
 }
 
-ushort table::fieldPackCopy(unsigned char* dest, short fieldNum)
+ushort table::fieldPackCopy(unsigned char* nullPtr, int& nullbit, unsigned char* dest, short fieldNum)
 {
     Field* fd = m_table->field[fieldNum];
     uint len = fd->pack_length();
@@ -1461,7 +1535,19 @@ ushort table::fieldPackCopy(unsigned char* dest, short fieldNum)
     }
     else
 #endif
+    {
         memcpy(dest, fd->ptr, len);
+        if (m_mysqlNull && nullPtr)
+        {
+            if (fd->is_null())
+            {
+                nullPtr += (nullbit / 8);
+                (*nullPtr) |= (unsigned char)(1L << (nullbit % 8));
+            }
+			if (fd->null_bit)
+				++nullbit;
+        }
+    }
     return (ushort)len;
 }
 
@@ -2106,7 +2192,7 @@ bool table::isNisKey(char num) const
     return false;
 }
 
-bool setNullIf(KEY& key)
+bool setNullIf(KEY& key, bool mysqlNull)
 {
     bool nullkey = false;
     Field* fd = key.key_part[0].field; // Nis is only in a head segment.
@@ -2120,14 +2206,14 @@ bool setNullIf(KEY& key)
         else
             fd->set_notnull();
     }
-    else
+    else if (!mysqlNull)
     {
         for (int j = 0; j < (int)key.user_defined_key_parts; j++)
         {
             fd = key.key_part[j].field;
             if (key.key_part[j].null_bit && fd->ptr)
             {
-                if (isNull(fd))
+                if (isNullValue(fd))
                 {
                     fd->set_null();
                     nullkey = true;
@@ -2153,7 +2239,7 @@ int table::setKeyNullFlags()
             KEY& key = m_table->key_info[i];
             if (key.flags & HA_NULL_PART_KEY)
             {
-                bool nullKey = setNullIf(key);
+                bool nullKey = setNullIf(key, m_mysqlNull);
                 if (nullKey && (i == m_keyNum))
                     ++setCount;
             }
@@ -2163,13 +2249,14 @@ int table::setKeyNullFlags()
 }
 
 /** Sets null value for all null able fields
+  This method effect only !mysqlNull
  */
-void table::setFiledNullFlags()
+void table::setFieldNullFlags()
 {
-    std::vector<Field*>::iterator it = m_nonKeySegNullFields.begin();
-    while (it != m_nonKeySegNullFields.end())
+    std::vector<Field*>::iterator it = m_noNullModeNullFieldList.begin();
+    while (it != m_noNullModeNullFieldList.end())
     {
-        if (isNull(*it))
+        if (isNullValue(*it))
             (*it)->set_null();
         else
             (*it)->set_notnull();
@@ -2184,13 +2271,13 @@ void table::setTimeStamp(bool insert)
     std::vector<Field*>::iterator it = m_timeStampFields.begin();
     while (it != m_timeStampFields.end())
     {
-        /*if (g_timestamp_always)
+        if (m_timestampAlways)
         {
             if ((insert && cp_has_insert_default_function((*it))) ||
                 (!insert && cp_has_update_default_function((*it))))
                 (*it)->store(0.0f);
-        }*/
-        if (/*!(*it)->is_null() &&*/ ((*it)->val_real() == 0))
+        }
+        if (!(*it)->is_null() && ((*it)->val_real() == 0))
         {
             if (insert)
                 cp_evaluate_insert_default_function((*it));
@@ -2213,9 +2300,9 @@ __int64 table::insert(bool ncc)
     {
         autoincSetup setup(m_table);
         setKeyNullFlags();
-        setFiledNullFlags();
+        if (!m_mysqlNull) setFieldNullFlags();
 		setTimeStamp(true /* insert */);
-
+        cp_setup_rpl_bitmap(m_table);
         m_stat = m_table->file->ha_write_row(m_table->record[0]);
         autoincValue = m_table->file->insert_id_for_cur_row;
 
@@ -2308,8 +2395,10 @@ void table::update(bool ncc)
     if (m_stat == 0)
     {
         int nullFieldsOfCurrentKey = setKeyNullFlags();
-        setFiledNullFlags();
+        if (!m_mysqlNull) setFieldNullFlags();
 		setTimeStamp(false /* update */);
+        cp_setup_rpl_bitmap(m_table);
+
         m_stat = m_table->file->ha_update_row(m_table->record[1],
                                               m_table->record[0]);
         if (m_stat == 0 || (m_stat == HA_ERR_RECORD_IS_THE_SAME))
@@ -2489,6 +2578,41 @@ void table::setKeyValues(const std::vector<std::string>& values, int keypart,
     key_copy(&m_keybuf[0], m_table->record[0], &key, KEYLEN_ALLCOPY);
 }
 
+unsigned int table::writeDefaultImage(unsigned char* p, size_t size)
+{
+    unsigned short cllen = (unsigned short)recordLenCl();
+    unsigned short len = cllen + m_nullBytesCl;
+    int offset = m_table->s->null_bytes;
+    memcpy(p, &len, sizeof(unsigned short));
+    p += sizeof(ushort_td);
+    if (size - 2 >= len)
+        memcpy(p + m_nullBytesCl, m_table->s->default_values + offset, cllen);
+    
+    unsigned char* src = m_table->s->default_values;
+    for (int i = 0 ; i < m_nullBytesCl; ++i)
+    {
+        *p = *src;
+        if (!(m_table->s->db_create_options & HA_OPTION_PACK_RECORD))
+        {
+            *p = *p >> 1;
+            *p |= (*(src + 1) & 1) ? 0xf0 : 0;
+        }
+        ++p; ++src;
+    }
+    return len + sizeof(unsigned short);
+}
+
+unsigned int table::writeSchemaImage(unsigned char* p, size_t size)
+{
+    protocol::tdap::tabledef* td = schemaBuilder().getTabledef(this, 0, m_mysqlNull, p + 2, size - 2);
+    unsigned short len = 0;
+    if (td)
+        len = td->varSize + 4;
+    memcpy(p, &len, sizeof(unsigned short));
+    return len + sizeof(unsigned short);
+}
+
+
 #ifdef USE_HANDLERSOCKET
 
 int table::fieldIndexByName(const char* name) const
@@ -2545,6 +2669,7 @@ void table::checkFiledIndex(int index)
     assert(index >= 0);
 }
 
+
 #endif // USE_HANDLERSOCKET
 
 } // namespace mysql

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

@@ -112,16 +112,16 @@ public:
 private:
     std::string m_dbname;
     mutable THD* m_thd;
+    table* m_inAutoTransaction;
+    tableList m_tables;
+    ulong m_privilege;
     int m_inTransaction;
     int m_inSnapshot;
     int m_stat;
     int m_usingExclusive;
-    table* m_inAutoTransaction;
     short m_trnType;
     short m_cid;
     enum_tx_isolation m_iso;
-    tableList m_tables;
-    ulong m_privilege;
    
     TABLE* doOpenTable(const std::string& name, short mode,
                                 const char* ownerName);
@@ -217,13 +217,13 @@ class bookmarks;
  */
 class keynumConvert
 {
-    KEY* m_key;
+    const KEY* m_key;
     int m_keyCount;
     char m_keyNum;
     char m_convNum;
 
 public:
-    keynumConvert(KEY* key, int count)
+    keynumConvert(const KEY* key, int count)
         : m_key(key), m_keyCount(count), m_keyNum(-1), m_convNum(-1)
     {
     }
@@ -241,6 +241,16 @@ public:
                 return m_convNum = i;
         return m_convNum = num; // If not found, a value as it is returned.
     }
+
+    char clientKeynum(char num)
+    {
+        if (num < m_keyCount)
+        {
+            if (strstr(m_key[num].name, "key"))
+                return m_key[num].name[3] - '0';
+        }
+        return -1;
+    }
 };
 
 class table : private boost::noncopyable
@@ -252,7 +262,7 @@ class table : private boost::noncopyable
     std::string m_name;
 
     short m_mode;
-    unsigned short m_nullFields;
+    unsigned short m_nisNullFields;
     int m_id;
     uint m_recordLenCl;
     int m_recordFormatType;
@@ -268,13 +278,14 @@ class table : private boost::noncopyable
     String m_str;
     keynumConvert m_keyconv;
     IblobBuffer* m_blobBuffer;
-	std::vector<Field*> m_timeStampFields;
-    std::vector<Field*> m_nonKeySegNullFields;
+    std::vector<Field*> m_noNullModeNullFieldList;
+    std::vector<Field*> m_timeStampFields;
     unsigned int m_readCount;
     unsigned int m_updCount;
     unsigned int m_delCount;
     unsigned int m_insCount;
     char m_keyNum;
+    unsigned char m_nullBytesCl;
     struct
     {
         bool m_nonNcc : 1;
@@ -289,10 +300,12 @@ class table : private boost::noncopyable
     struct
     {
         bool m_forceConsistentRead : 1;
+        bool m_mysqlNull : 1;
+        bool m_timestampAlways : 1;
     };
 
     table(TABLE* table, database& db, const std::string& name, short mode,
-          int id);
+          int id, bool mysqlnull);
     void moveKey(boost::function<int()> func);
     void readRecords(IReadRecordsHandler* handler, bool includeCurrent,
                      int type, bool noBookmark);
@@ -301,7 +314,7 @@ class table : private boost::noncopyable
     void preBuildPercent(uchar* first, uchar* last);
     void seekPos(const uchar* pos);
     int setKeyNullFlags();
-    void setFiledNullFlags();
+    void setFieldNullFlags();
 	void setTimeStamp(bool insert);
 
     bookmarks* bms();
@@ -550,7 +563,7 @@ public:
                              const bzs::db::blobHeader* hd);
     uint recordPackCopy(char* buf, uint maxsize = 0);
 
-    ushort fieldPackCopy(unsigned char* dest, short fieldNum);
+    ushort fieldPackCopy(unsigned char* nullPtr, int& nullbit, unsigned char* dest, short fieldNum);
 
     inline uint fieldSizeByte(int fieldNum)
     {
@@ -587,10 +600,17 @@ public:
     {
         return m_table->field[fieldNum]->flags;
     }
+    
+    inline bool isLegacyTimeFormat(int fieldNum) const
+    {
+        return m_table->field[fieldNum]->key_type() != HA_KEYTYPE_BINARY;
+    }
 
     inline unsigned short fields() const { return m_table->s->fields; }
 
-    inline unsigned int nisFields() const { return m_nullFields; }
+    inline bool isMysqlNull() const { return m_mysqlNull; }
+
+    inline unsigned int nisFields() const { return m_nisNullFields; }
 
     inline const char* fieldName(int fieldNum) const
     {
@@ -612,14 +632,14 @@ public:
 
     inline const KEY* primaryKey() const
     {
-        return (m_table->s->primary_key != MAX_KEY)
+        return (m_table->s->primary_key <= MAX_KEY)
                    ? &m_table->key_info[m_table->s->primary_key]
                    : NULL;
     }
 
     inline Field* field(int fieldNum) const { return m_table->field[fieldNum]; }
 
-    inline char primarykey() const { return m_table->s->primary_key; }
+    inline char primarykeyNum() const { return m_table->s->primary_key; }
 
     /** is this view. not table */
     inline bool isView() const { return m_table->s->is_view; }
@@ -752,13 +772,22 @@ public:
     void setKeyValues(const std::vector<std::string>& values, int keypart,
                     const std::string* inValue = NULL);
 
-    inline  unsigned int readCount() const { return m_readCount; }
+    unsigned int writeDefaultImage(unsigned char* p, size_t size);
+
+    unsigned int writeSchemaImage(unsigned char* p, size_t size);
+
+
+    void restoreRecord() { restore_record(m_table, s->default_values);}
+
+    inline unsigned int readCount() const { return m_readCount; }
+
+    inline unsigned int updCount() const { return m_updCount; }
 
-    inline  unsigned int updCount() const { return m_updCount; }
+    inline unsigned int delCount() const { return m_delCount; }
 
-    inline  unsigned int delCount() const { return m_delCount; }
+    inline unsigned int insCount() const { return m_insCount; }
 
-    inline  unsigned int insCount() const { return m_insCount; }
+    inline void setTimestampAlways(bool v) { m_timestampAlways = v;}
 };
 
 class fieldBitmap

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

@@ -229,6 +229,7 @@ int dbManager::ddl_execSql(THD* thd, const std::string& sql_stmt)
     //    result = 1;
     if (thd->is_error())
         result = errorCode(thd->cp_get_sql_error());
+    cp_lex_clear(thd); // reset values for insert
     return result;
 }