transactd 2.4.5 → 3.0.0

data/source/bzs/db/protocol/tdap/myDateTime.h

@@ -0,0 +1,294 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_MYDATETIME_H
+#define BZS_DB_PROTOCOL_TDAP_MYDATETIME_H
+/*=================================================================
+   Copyright (C) 2015 BizStation Corp All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; either version 2
+   of the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
+=================================================================*/
+#include <tchar.h>
+#include <bzs/env/compiler.h>
+#include <stddef.h>
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+/** @cond INTERNAL */
+
+#pragma pack(push, 1)
+pragma_pack1;
+
+struct PACKAGE myDate
+{
+    union
+    {
+	    struct
+	    {
+	        unsigned int dd : 5;
+	        unsigned int mm : 4;
+	        unsigned int yy : 15;
+	        unsigned int tmp : 8;
+	    };
+	    int i;
+	};
+    inline myDate() {};
+    inline myDate(int /*dec*/, bool /*bigendian*/) {};
+    void setValue(int v, bool btrDate_i = false);
+    int getValue(bool btrvValue = false);
+    char* toString(char* p, size_t size, bool w3_format = false);
+    myDate& operator=(const char* p);
+#ifdef _WIN32
+    wchar_t* toString(wchar_t* p, size_t size, bool w3_format = false);
+    myDate& operator=(const wchar_t* p);
+#endif
+    inline __int64 internalValue() const { return i; }
+    inline void setInternalValue(__int64 v) { i = (int)v; }
+};
+
+struct PACKAGE myTime
+{
+
+protected:
+    int m_dec;
+    bool m_bigendian;
+public:
+    union
+    {
+        struct
+        {
+            unsigned __int64 ms : 24;
+            unsigned __int64 ss : 6;
+            unsigned __int64 nn : 6;
+            unsigned __int64 hh : 10;
+            unsigned __int64 unused : 1;
+            unsigned __int64 sign : 1;
+            unsigned __int64 tmp : 16;
+        };
+        __int64 i64;
+    };
+
+public:
+    inline myTime(int dec, bool bigendian) : m_dec(dec), 
+        m_bigendian(bigendian){};
+    virtual void setValue(__int64 v, bool btrTime_i = false);
+    virtual __int64 getValue(bool btrTime_i = false);
+    char* toString(char* p, size_t size);
+    myTime& operator=(const char* p);
+#ifdef _WIN32
+    wchar_t* toString(wchar_t* p, size_t size);
+    myTime& operator=(const wchar_t* p);
+#endif
+    inline __int64 internalValue() const { return i64; }
+    inline void setInternalValue(__int64 v) { i64 = v; }
+};
+
+struct PACKAGE maTime : public  myTime
+{
+    virtual void setValue(__int64 v, bool btrTime_i = false);
+    virtual __int64 getValue(bool btrTime_i = false);
+public:
+    inline maTime(int dec, bool bigendian) : myTime(dec, bigendian){}
+    maTime& operator=(const char* p);
+#ifdef _WIN32
+    maTime& operator=(const wchar_t* p) ;
+#endif
+};
+
+struct PACKAGE myDateTime
+{
+protected:
+    int m_dec;
+    bool m_bigendian;
+public:
+    union
+    {
+        struct
+        {
+            unsigned __int64 ms : 24;
+            unsigned __int64 ss : 6;
+            unsigned __int64 nn : 6;
+            unsigned __int64 hh : 5;
+            unsigned __int64 dd : 5;
+            unsigned __int64 yymm : 17; // yy*13+mm   (yy 0-9999, mm 0-12)
+            unsigned __int64 sign : 1;  //always 1 0 is reserved
+        };
+        __int64 i64;
+    };
+
+    inline myDateTime(int dec, bool bigendian) : m_dec(dec), m_bigendian(bigendian){};
+    virtual void setValue(__int64 v);
+    virtual __int64 getValue();
+    char* toString(char* p, size_t size) const;
+    myDateTime& operator=(const char* p);
+    char* dateStr(char* p, size_t size) const;
+    char* timeStr(char* p, size_t size) const;
+    void setTime(const char* p);
+
+#ifdef _WIN32
+    wchar_t* toString(wchar_t* p, size_t size) const ;
+    myDateTime& operator=(const wchar_t* p) ;
+    wchar_t* dateStr(wchar_t* p, size_t size) const;
+    wchar_t* timeStr(wchar_t*, size_t size) const;
+    void setTime(const wchar_t* p);
+#endif
+    inline __int64 internalValue() const { return i64; }
+    inline void setInternalValue(__int64 v) { i64 = v; }
+};
+
+struct PACKAGE maDateTime : public  myDateTime
+{
+    virtual void setValue(__int64 v);
+    virtual __int64 getValue();
+public:
+    inline maDateTime(int dec, bool bigendian) : myDateTime(dec, bigendian){};
+    maDateTime& operator=(const char* p);
+#ifdef _WIN32
+    maDateTime& operator=(const wchar_t* p) ;
+#endif
+};
+
+struct PACKAGE myTimeStamp
+{
+private:
+    int m_dec;
+    bool m_bigendian;
+protected:
+    bool m_mariadb;
+public:
+    union
+    {
+        struct
+        {
+            unsigned __int64 ms : 24;
+            unsigned __int64 datetime : 32;
+            unsigned __int64 tmp : 8;
+        };
+        __int64 i64;
+    };
+
+    inline myTimeStamp(int dec, bool bigendian) : m_dec(dec), 
+    	m_bigendian(bigendian), m_mariadb(false){};
+    void setValue(__int64 v);
+    __int64 getValue();
+    char* toString(char* p, size_t size);
+    myTimeStamp& operator=(const char* p);
+    char* dateStr(char* p, size_t size) const;
+    char* timeStr(char* p, size_t size) const;
+
+#ifdef _WIN32
+    wchar_t* toString(wchar_t* p, size_t size);
+    myTimeStamp& operator=(const wchar_t* p);
+    wchar_t* dateStr(wchar_t* p, size_t size) const;
+    wchar_t* timeStr(wchar_t* p, size_t size) const;
+#endif
+    inline __int64 internalValue() const { return i64; }
+    inline void setInternalValue(__int64 v) { i64 = v; }
+};
+
+
+struct PACKAGE maTimeStamp : public myTimeStamp
+{
+
+    inline maTimeStamp (int dec, bool bigendian) : myTimeStamp(dec, bigendian)
+    {
+        m_mariadb = true;
+    }
+    inline maTimeStamp& operator=(const char* p){ myTimeStamp::operator=(p); return *this;}
+#ifdef _WIN32
+    inline maTimeStamp& operator=(const wchar_t* p) { myTimeStamp::operator=(p); return *this; }
+#endif
+};
+
+inline int btrdateToMydate(int btrd)
+{
+    myDate myd;
+    myd.setValue(btrd, true);
+    return myd.getValue(true);
+}
+
+// Do not work at maridab
+inline __int64 btrtimeToMytime(int btrTime_i, bool bigendian)
+{
+    myTime myt(4, bigendian);
+    myt.setValue(btrTime_i, true);
+    return myt.getValue(true);
+}
+
+inline int mydateToBtrdate(int myDate_i)
+{
+    myDate myd;
+    myd.setValue(myDate_i, false);
+    return myd.getValue(true);
+}
+
+inline int mytimeToBtrtime(__int64 myTime_i, bool bigendian, int dec)
+{
+    myTime myt(dec, bigendian);
+    myt.setValue(myTime_i, false);
+    return (int)myt.getValue(true);
+}
+
+template <class T>
+__int64 getInternalValue(int dec, bool bigendian, __int64 value)
+{
+    T t(dec, bigendian);
+    t.setValue(value);
+    return t.internalValue();
+}
+
+template <class T>
+__int64 getStoreValue(int dec, bool bigendian, __int64 value)
+{
+    T t(dec, bigendian);
+    t.setInternalValue(value);
+    return t.getValue();
+}
+
+#pragma warning(disable : 4244)
+template <class T, typename CHAR>
+const CHAR* date_time_str(int dec, bool bigendian, __int64 value, CHAR* buf, size_t size)
+{
+    T t(dec, bigendian);
+    t.setValue(value);
+    return t.toString(buf, size);
+}
+
+template <class T, class T2>
+inline __int64 str_to_64(int dec, bool bigendian, const T2* data)
+{
+    T t(dec, bigendian);
+    t = data;
+    return t.getValue();
+}
+
+#pragma warning(default : 4244)
+
+
+
+#pragma pack(pop)
+pragma_pop;
+/** @endcond */
+
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
+
+#endif //BZS_DB_PROTOCOL_TDAP_MYDATETIME_H

data/source/bzs/db/protocol/tdap/mysql/databaseSchema.cpp

@@ -43,7 +43,7 @@ namespace tdap
 namespace mysql
 {
 
-schemaBuilder::schemaBuilder(void)
+schemaBuilder::schemaBuilder(void): m_stat(0)
 {
 }
 
@@ -72,12 +72,12 @@ uchar_td convFieldType(enum enum_field_types type, uint flags, bool binary,
     switch (type)
     {
     case MYSQL_TYPE_DECIMAL:
-        return ft_decimal;
+    case MYSQL_TYPE_NEWDECIMAL:
+        return ft_mydecimal;
     case MYSQL_TYPE_TINY:
     case MYSQL_TYPE_SHORT:
     case MYSQL_TYPE_LONG:
     case MYSQL_TYPE_LONGLONG:
-    case MYSQL_TYPE_YEAR:
     case MYSQL_TYPE_INT24:
         if (flags & AUTO_INCREMENT_FLAG)
             return (flags & UNSIGNED_FLAG) ? ft_autoIncUnsigned : ft_autoinc;
@@ -85,29 +85,24 @@ uchar_td convFieldType(enum enum_field_types type, uint flags, bool binary,
             return ft_uinteger;
         return ft_integer;
     case MYSQL_TYPE_ENUM:
+        return ft_enum;
     case MYSQL_TYPE_SET:
+        return ft_set;
     case MYSQL_TYPE_BIT:
-        return ft_uinteger;
+        return ft_bit;
     case MYSQL_TYPE_FLOAT:
     case MYSQL_TYPE_DOUBLE:
         return ft_float;
+    case MYSQL_TYPE_YEAR:
+        return ft_myyear;
     case MYSQL_TYPE_DATE:
-	case MYSQL_TYPE_NEWDATE:
+    case MYSQL_TYPE_NEWDATE:
         return ft_mydate;
     case MYSQL_TYPE_TIME:
-#if(MYSQL_VERSION_ID > 50600)
-    case MYSQL_TYPE_TIME2:
-#endif
         return ft_mytime;
     case MYSQL_TYPE_DATETIME:
-#if(MYSQL_VERSION_ID > 50600)
-    case MYSQL_TYPE_DATETIME2:
-#endif
         return ft_mydatetime;
     case MYSQL_TYPE_TIMESTAMP:
-#if(MYSQL_VERSION_ID > 50600)
-    case MYSQL_TYPE_TIMESTAMP2:
-#endif
         return ft_mytimestamp;
     case MYSQL_TYPE_VARCHAR:
     case MYSQL_TYPE_VAR_STRING: //?
@@ -125,6 +120,20 @@ uchar_td convFieldType(enum enum_field_types type, uint flags, bool binary,
         if (flags & BINARY_FLAG)
             return ft_myblob;
         return ft_mytext;
+    case MYSQL_TYPE_GEOMETRY:
+        return ft_mygeometry;
+#if ((MYSQL_VERSION_ID > 50700) && (MYSQL_VERSION_ID < 100000))
+    case MYSQL_TYPE_JSON:
+        return ft_myjson;
+#endif
+#if(MYSQL_VERSION_ID > 50600)
+    case MYSQL_TYPE_TIME2:
+        return ft_mytime;
+    case MYSQL_TYPE_DATETIME2:
+        return ft_mydatetime;
+    case MYSQL_TYPE_TIMESTAMP2:
+        return ft_mytimestamp;
+#endif
     default: // MYSQL_TYPE_NEWDECIMAL MYSQL_TYPE_GEOMETRY
         return unicode ? ft_wstring : ft_string;
     }
@@ -142,67 +151,136 @@ bool isBinary(const CHARSET_INFO& cs)
     return (&cs == &my_charset_bin);
 }
 
-short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
-{
+tabledef* schemaBuilder::getTabledef(engine::mysql::table* src, int id, 
+                        bool nouseNullkey, uchar* rec, size_t size)
+{   
+    
+    src->restoreRecord();
+    size_t tdSizelen =  (sizeof(tabledef) + (sizeof(fielddef) * src->fields()) +
+                            (sizeof(keydef) * src->keys()));
+
+    if (size < tdSizelen)
+    {
+        m_stat = STATUS_BUFFERTOOSMALL;
+        return NULL;
+    }
+    // index
+    keynumConvert kc(&src->keyDef(0), src->keys());
+
     uint_td datalen = 0;
-    boost::shared_array<uchar> rec(new uchar[65000]);
     // table
-    tabledef& tdef = (tabledef&)(*rec.get());
-    initTableDef(src, tdef, id);
-    tdef.fieldCount = (uchar_td)src->fields();
-    tdef.keyCount = (uchar_td)src->keys();
-    tdef.charsetIndex = charsetIndex(src->charset().csname);
-    tdef.primaryKeyNum =
-        (src->primarykey() < tdef.keyCount) ? src->primarykey() : -1;
+    tabledef& td = (*((tabledef*)rec));
+    initTableDef(src, td, id);
+    td.fieldCount = (uchar_td)src->fields();
+    td.keyCount = (uchar_td)src->keys();
+    td.charsetIndex = charsetIndex(src->charset().csname);
+    td.primaryKeyNum =
+        (src->primarykeyNum() < td.keyCount) ? kc.clientKeynum(src->primarykeyNum()) : -1;
 #ifdef USE_BTRV_VARIABLE_LEN
-    tdef.flags.bit0 = (src->recordFormatType() & RF_FIXED_PLUS_VALIABLE_LEN);
+    td.flags.bit0 = (src->recordFormatType() & RF_FIXED_PLUS_VALIABLE_LEN);
     if (src->recordFormatType() & RF_FIXED_PLUS_VALIABLE_LEN)
-        tdef.fixedRecordLen =
+        td.fixedRecordLen =
             (ushort_td)(src->recordLenCl() - src->lastVarFieldDataLen());
     else
 #endif
-        tdef.fixedRecordLen = (ushort_td)src->recordLenCl();
-    tdef.maxRecordLen = (ushort_td)src->recordLenCl();
-    tdef.pageSize = 2048;
-    tdef.optionFlags.bitA = ((src->recordFormatType() & RF_VALIABLE_LEN) != 0);
-    tdef.optionFlags.bitB = (src->blobFields() != 0);
-
+        td.fixedRecordLen = (ushort_td)src->recordLenCl();
+    td.m_maxRecordLen = (ushort_td)src->recordLenCl();
+    td.optionFlags.bitA = ((src->recordFormatType() & RF_VALIABLE_LEN) != 0);
+    td.optionFlags.bitB = (src->blobFields() != 0);
+#if defined(MARIADB_BASE_VERSION)
+    td.m_useInMariadb = true;
+#else
+    td.m_useInMariadb = false;
+#endif
+    td.m_srvMinorVer = (MYSQL_VERSION_ID / 100) % 100;
     datalen += sizeof(tabledef);
-    tdef.fieldDefs = (fielddef*)(rec.get() + datalen);
+    td.fieldDefs = (fielddef*)(rec + datalen);
     // field
     ushort_td pos = 0;
+    String str;
     for (int i = 0; i < src->fields(); ++i)
     {
         if (isNisField(src->fieldName(i)))
-            --tdef.fieldCount;
+            --td.fieldCount;
         else
         {
             fielddef fd;
-            memset(&fd, 0, sizeof(fielddef));
+            Field* f = src->field(i);
+            memset(&fd, 0, sizeof(fd));
             fd.setName(src->fieldName(i));
             fd.len = src->fieldLen(i); // filed->pack_length();
             fd.pos = pos;
             fd.type = convFieldType(src->fieldRealType(i), src->fieldFlags(i),
                                     isBinary(src->fieldCharset(i)),
                                     isUnicode(src->fieldCharset(i)));
-            bool usePadChar = ((fd.type == ft_mychar) || (fd.type == ft_mywchar)); 
-            fd.setPadCharSettings(usePadChar, true);
-            fd.setCharsetIndex(charsetIndex(src->fieldCharset(i).csname));
+            if ((fd.type == ft_mytime) || (fd.type == ft_mydatetime) || (fd.type == ft_mytimestamp))
+            {
+                if (src->isLegacyTimeFormat(i))
+                    fd.m_options |= FIELD_OPTION_REGACY_TIME;
+
+                //for mariadb
+                #if defined(MARIADB_BASE_VERSION)
+                    if(td.isMariaTimeFormat())
+                        fd.m_options |= FIELD_OPTION_MARIADB;
+                #endif
+            }
+
+            if (fd.type == ft_mydecimal)
+            {
+                fd.digits = my_decimal_length_to_precision(f->field_length, f->decimals(),
+								(f->flags & UNSIGNED_FLAG) != 0);
+            }
+ 
+            fd.setPadCharSettings(false, true);
+            if (fd.isStringType())
+                fd.setCharsetIndex(charsetIndex(src->fieldCharset(i).csname));
+
+            if ((fd.type == ft_mydatetime || fd.type == ft_mytimestamp) && (f->val_real() == 0))
+            {// No constant value
+                fd.setDefaultValue(0.0f);
+                if (cp_has_insert_default_function(f)) 
+                    fd.setDefaultValue(DFV_TIMESTAMP_DEFAULT);
+            }
+            else if (fd.isIntegerType())
+                fd.setDefaultValue((__int64)f->val_int());
+            else
+            {
+                f->val_str(&str, &str);
+                fd.setDefaultValue(str.c_ptr());
+            }
+            fd.setNullable(f->null_bit != 0, f->is_null());
+            if (fd.isNullable()) ++td.m_nullfields;
+            if ((fd.type == ft_mydatetime || fd.type == ft_mytimestamp) && 
+                                    cp_has_update_default_function(f))
+                fd.setTimeStampOnUpdate(true); 
+
+            fd.decimals = (uchar_td)f->decimals();
+            if (fd.decimals == NOT_FIXED_DEC)
+                fd.decimals = 0;
+
+            if (td.isLegacyTimeFormat(fd))
+            {
+                fd.m_options |= FIELD_OPTION_REGACY_TIME;
+                fd.decimals = 0;
+            }
+            else
+                fd.m_options &= ~FIELD_OPTION_REGACY_TIME;
             pos += fd.len;
             datalen =
-                copyToRecordImage(rec.get(), &fd, sizeof(fielddef), datalen);
+                copyToRecordImage(rec, &fd, sizeof(fielddef), datalen);
         }
     }
+    td.m_nullbytes = (td.m_nullfields + 7) / 8;
 
-    // index
     for (int i = 0; i < src->keys(); ++i)
     {
-        const KEY& key = src->keyDef(i);
+        const KEY& key = src->keyDef(kc.keyNumByMakeOrder(i));
         keydef kd;
         memset(&kd, 0, sizeof(keydef));
         kd.segmentCount = key.user_defined_key_parts;
         kd.keyNumber = i;
         int segNum = 0;
+        bool allNullkey = true;
         for (int j = 0; j < (int)key.user_defined_key_parts; ++j)
         {
             keySegment& sg = kd.segments[segNum];
@@ -216,7 +294,9 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
                 sg.flags.bit1 = 1; // change able
                 sg.flags.bit4 = (j != kd.segmentCount - 1); // segment
                 sg.flags.bit8 = 1; // extend key type
-                sg.flags.bit9 = ks.null_bit ? 1 : 0; // null key
+                if (nouseNullkey == false)
+                    sg.flags.bit9 = ks.null_bit ? 1 : 0; // null key
+                allNullkey = allNullkey & sg.flags.bit9;
                 if (isStringTypeForIndex(convFieldType(
                         src->fieldType(sg.fieldNum),
                         src->fieldFlags(sg.fieldNum),
@@ -224,21 +304,51 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
                         isUnicode(src->fieldCharset(sg.fieldNum)))))
                     sg.flags.bitA =
                         !(src->fieldFlags(sg.fieldNum) & BINARY_FLAG);// case in-sencitive
-                if (src->fieldDataLen(sg.fieldNum) != ks.length)
-                {
-                    fielddef& fd = tdef.fieldDefs[sg.fieldNum];
-                    // suppot prefix key
-                    fd.keylen = ks.length;
-                }
+
+                Field* f = src->field(sg.fieldNum);
+                if (f->pack_length() != ks.length + var_bytes_if(f))
+                    td.fieldDefs[sg.fieldNum].keylen = ks.length ; // suppot prefix key
                 ++segNum;
             }
         }
-        datalen = copyToRecordImage(rec.get(), &kd, sizeof(keydef), datalen);
+        if (allNullkey)
+        {
+            for (int i=0;i<kd.segmentCount; ++i)
+            {
+                kd.segments[segNum].flags.bit9 = 0; //part segment null key
+                kd.segments[segNum].flags.bit3 = 1; //all segment null key
+            }
+        }
+        datalen = copyToRecordImage(rec, &kd, sizeof(keydef), datalen);
+    }
+    td = (tabledef&)(*rec);
+    td.varSize = datalen - 4;
+    td.setFielddefsPtr();
+    td.setKeydefsPtr();
+
+    return &td;
+}
+
+tabledef* schemaBuilder::getTabledef(database* db, const char* tablename, uchar* rec, size_t size)
+{
+    table* tb = db->openTable(tablename, TD_OPEN_READONLY, NULL);
+    if (db->stat()) 
+    {
+        m_stat = db->stat();
+        return NULL;
     }
-    tdef = (tabledef&)(*rec.get());
-    tdef.varSize = datalen - 4;
+    tabledef* td = getTabledef(tb, 0, true, rec, size);
+    db->closeTable(tb);
+    return td;
+}
+
+short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id, bool nouseNullkey)
+{
+    boost::shared_array<uchar> rec(new uchar[65000]);
+    
+    tabledef* td = getTabledef(src, id, nouseNullkey, rec.get(), 65000);
     mtb->clearBuffer();
-    mtb->setRecordFromPacked(rec.get(), datalen, NULL);
+    mtb->setRecordFromPacked(rec.get(), td->varSize + 4, NULL);
     mtb->insert(true);
     return mtb->stat();
 }
@@ -299,7 +409,7 @@ void schemaBuilder::listSchemaTable(database* db, std::vector<std::string>& shce
     }
 }
 
-short schemaBuilder::execute(database* db, table* mtb)
+short schemaBuilder::execute(database* db, table* mtb, bool nouseNullkey)
 {
     char path[FN_REFLEN + 1];
     build_table_filename(path, sizeof(path) - 1, db->name().c_str(), "", "", 0);
@@ -336,7 +446,7 @@ short schemaBuilder::execute(database* db, table* mtb)
         smartTransction trn(db);
         for (size_t i = 0; i < tables.size(); ++i)
         {
-            if ((stat = insertMetaRecord(mtb, tables[i], ++id)) != 0)
+            if ((stat = insertMetaRecord(mtb, tables[i], ++id, nouseNullkey)) != 0)
                     break;
         }
         if (stat == 0) trn.end();

data/source/bzs/db/protocol/tdap/mysql/databaseSchema.h

@@ -47,12 +47,15 @@ namespace mysql
 class schemaBuilder
 {
     short insertMetaRecord(engine::mysql::table* mtb, engine::mysql::table* src,
-                           int id);
-
+                           int id, bool nouseNullkey);
+    short m_stat;
 public:
     schemaBuilder();
     ~schemaBuilder();
-    short execute(engine::mysql::database* db, engine::mysql::table* mtb);
+    short stat() const { return m_stat;}
+    tabledef* getTabledef(engine::mysql::table* src, int id, bool nouseNullkey, uchar* rec, size_t size);
+    tabledef* getTabledef(engine::mysql::database* db, const char* tablename, uchar* rec, size_t size);
+    short execute(engine::mysql::database* db, engine::mysql::table* mtb, bool nouseNullkey);
     static void listSchemaTable(engine::mysql::database* db, std::vector<std::string>& shcemaNames);
 };