transactd 2.4.5 → 3.0.0

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

@@ -23,12 +23,13 @@
 #include <string.h>
 #include <algorithm>
 #include <wchar.h>
+#include <stdio.h>
 #include <bzs/env/compiler.h>
 #include <bzs/env/crosscompile.h>
 #include <bzs/db/protocol/tdap/mysql/characterset.h>
 #include <bzs/db/blobStructs.h>
 #include <assert.h>
-
+#include <bzs/db/protocol/tdap/myDateTime.h>
 namespace bzs
 {
 namespace db
@@ -37,10 +38,28 @@ namespace protocol
 {
 namespace tdap
 {
-
+
+namespace mysql
+{
+class schemaBuilder;
+}
 namespace client
 {
 class dbdef;
+class fielddefs;
+class table;
+class database;
+struct openTablePrams;
+struct dbdimple;
+class filter;
+class recordCache;
+class fielddefs;
+class fields;
+class field;
+class memoryRecord;
+struct logic;
+class recordsetQuery;
+class sqlBuilder;
 }
 
 #pragma pack(push, 1)
@@ -140,15 +159,52 @@ struct keySegment
     FLAGS flags; // key flags. 11 to 15bit is not use.
 };
 
+/** keySegment::flags
+*/
+#define kf_duplicatable   bit0
+#define kf_changeatable   bit1
+#define kf_allseg_nullkey bit3
+#define kf_order_desc     bit6
+#define kf_extend         bit8
+#define kf_seg_nullkey    bit9
+#define kf_incase         bitA
+
+
+
 /* brief A key infomation
  */
 #define MAX_KEY_SEGMENT 8
-
+#define COMP_KEY_FLAGS(l, r, NAME) (l.NAME == r.NAME)
 struct keydef
 {
-    uchar_td segmentCount; // Number of segment
-    keySegment segments[MAX_KEY_SEGMENT]; // key segments . max 8 segments
-    uchar_td keyNumber; // key number
+    uchar_td segmentCount;
+    keySegment segments[MAX_KEY_SEGMENT];
+    uchar_td keyNumber;
+
+    bool operator==(const keydef& r) const
+    {
+        if (this == &r) return true;
+        bool ret = (segmentCount == r.segmentCount) && (keyNumber == r.keyNumber);
+        if (!ret) return false;
+        for (int i = 0;i < segmentCount; ++i)
+        {
+            FLAGS f = segments[i].flags;
+            FLAGS rf = r.segments[i].flags;
+            ret = COMP_KEY_FLAGS(f, rf, kf_duplicatable) &&
+                  COMP_KEY_FLAGS(f, rf, kf_changeatable) &&
+                  COMP_KEY_FLAGS(f, rf, kf_allseg_nullkey) &&
+                  COMP_KEY_FLAGS(f, rf, kf_order_desc) &&
+                  COMP_KEY_FLAGS(f, rf, kf_seg_nullkey) &&
+                  COMP_KEY_FLAGS(f, rf, kf_incase);
+            if (!ret) return false;
+        }
+        return true;
+    }
+
+private:
+    short synchronize(const keydef* kd);
+    friend struct tabledef;
+    friend class client::dbdef;
 };
 
 static const int MYSQL_FDNAME_SIZE = 64;
@@ -157,12 +213,14 @@ static const int PERVASIVE_FDNAME_SIZE = 20;
 static const int FIELD_NAME_SIZE = MYSQL_FDNAME_SIZE;
 static const int TABLE_NAME_SIZE = 32;
 static const int FILE_NAME_SIZE = 266;
-
-#if (defined(__x86_32__) || __APPLE_32__)
-static const int TABLEDEF_FILLER_SIZE = 21; // 25-4;
+
+/** @cond INTERNAL */
+#if (defined(__x86_32__) || defined(__APPLE_32__))
+static const int TABLEDEF_FILLER_SIZE = 17; // 25-4-4;
 #else
-static const int TABLEDEF_FILLER_SIZE = 9; // 17-8;
-#endif
+static const int TABLEDEF_FILLER_SIZE = 1; // 17-8 -8;
+#endif
+/** @endcond */
 
 #ifndef MYSQL_DYNAMIC_PLUGIN
 
@@ -205,6 +263,8 @@ inline bool isStringType(uchar_td type)
 {
     switch (type)
     {
+    case ft_mygeometry:
+    case ft_myjson:
     case ft_myblob:
     case ft_mytext:
     case ft_lstring:
@@ -218,8 +278,56 @@ inline bool isStringType(uchar_td type)
 #define PAD_CHAR_OPTION_SAVED   1
 #define USE_PAD_CHAR            2
 #define TRIM_PAD_CHAR           4
+
+#define FIELD_OPTION_NULLABLE     1
+#define FIELD_OPTION_MARIADB      2
+#define FIELD_OPTION_REGACY_TIME  4
+
+#define DEFAULT_VALUE_SIZE      8
+
+//For decimals
+#define DIGITS_INT32 9
+static const int decimalBytesBySurplus[DIGITS_INT32 + 1] = {0, 1, 1, 2, 2, 3, 3, 4, 4, 4};
+
 /** @endcond */
 
+class bitset
+{
+    unsigned __int64 m_i64;
+
+public:
+    bitset() : m_i64(0) { }
+
+    bitset(__int64 v) : m_i64(v) { }
+
+    inline void set(int index, bool value)
+    {
+        unsigned __int64 bits = 1ULL << index;
+        m_i64 = value ? m_i64 | bits : m_i64 & ~bits;
+    }
+
+    inline bool get(int index) const
+    {
+        unsigned __int64 bits = 1ULL << index;
+        return (m_i64 & bits) != 0;
+    }
+
+    inline __int64 internalValue() const { return (__int64)m_i64; }
+
+    inline bool operator[](int index) const {return get(index); };
+
+    inline bool operator==(const bitset& r) const
+    {
+        return (m_i64 == r.m_i64);
+    }
+
+    inline bool contains(const bitset& r, bool all=true) const
+    {
+        return all ? ((m_i64 & r.m_i64) == r.m_i64) : ((m_i64 & r.m_i64) != 0);
+    }
+
+};
+
 /* Mark of ** that BizStation Corp internal use only.
  */
 template <int N> struct fielddef_t
@@ -235,21 +343,27 @@ public:
     ushort_td viewWidth; // ** view width pix
     double max; // ** max value
     double min; // ** min value
-    double defValue; // ** default value
+protected:
+    char m_defValue[DEFAULT_VALUE_SIZE];
+public:
     uchar_td lookTable; // ** reference table number
     uchar_td lookField; // ** field number of reference table
     uchar_td lookFields[3]; // ** View fields of reference    bit567
     ushort_td pos; // Field offset position from record image
-    ushort_td defViewWidth; // ** default view wifth
-
 protected:
+    uchar_td m_nullbit;    // bit number for null indicator
+    uchar_td m_nullbytes;  // byte of null indicator which head of record memory block.
     char m_chainChar[2];
 
 public:
-    ushort_td ddfid; // ddf field id
+union 
+{
+    ushort_td ddfid;  // ddf field id
+    ushort_td digits; // for ft_myDecimal
+};
     ushort_td filterId; // ** filter id for reference
     uchar_td filterKeynum; // ** key number for reference
-    uchar_td nullValue; // null value
+    uchar_td nullValue; // null value for P.SQL 
     ushort_td userOption; // ** option
     uchar_td lookDBNum; // ** database number of reference bitD
     
@@ -262,13 +376,17 @@ public:
 protected:
     uchar_td m_charsetIndex; // charctor set index of this field data
     ushort_td m_schemaCodePage;
-    ushort_td m_padCharOptions;
+    uchar_td m_padCharOptions;
+    uchar_td m_options;
+
 public:
     FLAGS enableFlags; // ** enable flags. see below
 
 private:
     inline void setSchemaCodePage(uint_td v) { m_schemaCodePage = (ushort_td)v; };
     friend class client::dbdef;
+    friend class client::fielddefs;
+    friend struct tabledef;
 };
 
 /* This is only for BizStation Corp internal.
@@ -276,7 +394,7 @@ private:
  bit0  show list view
  bit1  enable max value
  bit2  enable min value
- bit3  enable default value
+ bit3  reserved. not use
  bit4  enable lookTable
  bit5  enable lookFields[0]
  bit6  enable lookFields[1]
@@ -288,6 +406,7 @@ private:
  bitC  not show list view but add select field list
  bitD  enable lookDBNum
  bitE  field value is changed
+ bitF  defaultNull
  */
 
 typedef fielddef_t<MYSQL_FDNAME_SIZE> fielddef_t_my;
@@ -299,34 +418,103 @@ typedef fielddef_t<PERVASIVE_FDNAME_SIZE> fielddef_t_pv;
 
 struct PACKAGE fielddef : public fielddef_t_my
 {
+
 #ifdef _UNICODE
     const wchar_t* name() const; // Return a field name.
     const wchar_t* name(wchar_t* buf) const; // Return a field name to bufffer .
     const wchar_t* chainChar() const; // ** internal use only.
+    const wchar_t* defaultValue_str() const;
     void setName(const wchar_t* s);
     void setChainChar(const wchar_t* s); // ** internal use only.
+    void setDefaultValue(const wchar_t* s);
 #else // NOT _UNICODE
 
 #ifdef MYSQL_DYNAMIC_PLUGIN
 
-    inline const char* name() const { return m_name; };
+    //inline const char* name() const { return m_name; };
 
-    inline const char* chainChar() const { return m_chainChar; };
+    //inline const char* chainChar() const { return m_chainChar; };
+
+    //inline const char* defaultValue_str() const{return m_defValue; }
 
     inline void setName(const char* s)
     {
         strncpy_s(m_name, FIELD_NAME_SIZE, s, sizeof(m_name) - 1);
-    };
+    }
 
     inline void setChainChar(const char* s)
     {
         strncpy_s(m_chainChar, 2, s, sizeof(m_chainChar) - 1);
-    };
+    }
+
+    inline void setDefaultValue(const char* s)
+    {
+        if (isBlob())
+        {
+            memset(m_defValue, 0, DEFAULT_VALUE_SIZE);
+            return;
+        }
+
+        enableFlags.bitF = false;
+        __int64 i64 = 0;
+        switch(type)
+        {
+        case ft_time:
+        case ft_mytime:
+        {
+            myDateTime dt(7, true);
+            dt.setTime(s);
+            i64 = dt.getValue();
+            memcpy(m_defValue, &i64, 7);
+            return;
+        }
+        case ft_date:
+        case ft_mydate:
+        case ft_datetime:
+        case ft_mytimestamp:
+        case ft_mydatetime:
+            i64 = str_to_64<myDateTime, char>(7, true, s);
+            memcpy(m_defValue, &i64, 7);
+            return;
+        case ft_integer:
+        case ft_autoinc:
+            *((__int64*)m_defValue) = _atoi64(s);
+            return;
+        case ft_uinteger:
+        case ft_logical:
+        case ft_set:
+        case ft_bit:
+        case ft_enum:
+        case ft_autoIncUnsigned:
+        case ft_myyear:
+            *((unsigned __int64*)m_defValue) = strtoull(s, NULL, 10);
+            return;
+        }
+    
+        if (isNumericType())
+        {
+            *((double*)m_defValue) = atof(s);
+            return;
+        }
+        strncpy_s(m_defValue, 8, s, sizeof(m_defValue) - 1);
+    }
+
+    inline void setDefaultValue(double v)
+    {
+        *((double*)m_defValue) = v;
+    }
+
+    inline void setDefaultValue(__int64 v)
+    {
+        *((__int64*)m_defValue) = v;
+    }
+
 
 #else // NOT MYSQL_DYNAMIC_PLUGIN
     const char* name() const;
     const char* name(char* buf) const;
     const char* chainChar() const;
+    const char* defaultValue_str() const;
     void setName(const char* s);
     void setChainChar(const char* s);
 #endif // NOT MYSQL_DYNAMIC_PLUGIN
@@ -337,8 +525,23 @@ struct PACKAGE fielddef : public fielddef_t_my
     inline void setNameA(const char* s)
     {
         strncpy_s(m_name, FIELD_NAME_SIZE, s, sizeof(m_name) - 1);
-    };
+    }
+
 #ifndef MYSQL_DYNAMIC_PLUGIN
+    void setDefaultValue(const char* s);
+
+    void setDefaultValue(__int64 v);
+
+    void setDefaultValue(double v);
+
+    void setDefaultValue(const bitset& v)
+    {
+        setDefaultValue(v.internalValue());
+    }
+
+    double defaultValue() const;
+
+    __int64 defaultValue64() const;
 
     inline const _TCHAR* typeName() const { return getTypeName(type); };
 
@@ -349,22 +552,9 @@ struct PACKAGE fielddef : public fielddef_t_my
         len = lenByCharnum(type, m_charsetIndex, charnum);
     }
 
+    void setDecimalDigits(int dig, int dec);
 #endif // MYSQL_DYNAMIC_PLUGIN
 
-private:
-    /* Is variable key type
-     */
-    inline bool isKeyVarType() const
-    {
-        return (((type >= ft_myvarchar) && (type <= ft_mywvarbinary)) ||
-                (type == ft_myblob) || (type == ft_mytext));
-    }
-
-    /* max key segment length. not include sizeBytes.
-     */
-    inline ushort_td maxKeylen() const { return keylen ? keylen : len; };
-
-public:
     inline unsigned int codePage() const
     {
         return mysql::codePage((unsigned short)m_charsetIndex);
@@ -372,22 +562,46 @@ public:
 
     /* Is string type or not.
     */
-    bool isStringType() const;
+    inline bool isStringType() const {return tdap::isStringType(type);}
+
+    inline bool isPadCharType() const
+    {
+        return ((type == ft_mychar) || (type == ft_mywchar) ||
+                (type == ft_string) || (type == ft_wstring));
+    }
+
+    inline bool isIntegerType() const
+    {
+        return ((type == ft_integer) || (type == ft_logical) || (type == ft_uinteger) || 
+                (type == ft_autoinc) || (type == ft_set) || (type == ft_bit) || 
+                (type == ft_enum) || (type == ft_autoIncUnsigned) || (type == ft_myyear));
+    }
 
     inline bool isNumericType() const
     {
         return ((type == ft_integer) || (type == ft_decimal) ||
-                (type == ft_money) || (type == ft_logical) ||
-                (type == ft_numeric) || (type == ft_bfloat) ||
-                (type == ft_uinteger) || (type == ft_autoinc) ||
-                (type == ft_bit) || (type == ft_numericsts) ||
-                (type == ft_numericsa) || (type == ft_autoIncUnsigned));
+                (type == ft_money) || (type == ft_logical) || (type == ft_currency) ||
+                (type == ft_numeric) || (type == ft_bfloat) || (type == ft_float) ||
+                (type == ft_uinteger) || (type == ft_autoinc) || (type == ft_set) ||
+                (type == ft_bit) || (type == ft_enum) || (type == ft_numericsts) ||
+                (type == ft_numericsa) || (type == ft_autoIncUnsigned) ||
+                (type == ft_myyear) || (type == ft_mydecimal));
+    }
+
+    inline bool isDateTimeType() const
+    {
+        return ((type == ft_date) || (type == ft_mydate) ||
+                (type == ft_time) || (type == ft_mytime) ||
+                (type == ft_datetime) || (type == ft_timestamp) ||
+                (type == ft_mydatetime) || (type == ft_mytimestamp));
     }
 
     /* Charctor numbers from charset.
      */
     unsigned int charNum() const;
 
+    bool isValidCharNum() const;
+
     inline void setCharsetIndex(uchar_td index)
     {
         m_charsetIndex = index;
@@ -399,9 +613,86 @@ public:
 
     inline uchar_td charsetIndex() const { return m_charsetIndex; };
     
+    inline bool isBlob() const
+    {
+        return (type == ft_myblob) || (type == ft_mytext) || (type == ft_mygeometry) || (type == ft_myjson);
+    }
+
+    inline void setPadCharSettings(bool set, bool trim)
+    {
+        m_padCharOptions = 0;
+        m_padCharOptions |= PAD_CHAR_OPTION_SAVED;
+        if ((type == ft_mychar) || (type == ft_mywchar))
+        {
+            m_padCharOptions |= USE_PAD_CHAR;
+            if (trim)
+                m_padCharOptions |= TRIM_PAD_CHAR;
+        }    // For compatibility with conventional.
+        else if ((type == ft_string) || (type == ft_wstring))
+        {
+             if (set)
+                m_padCharOptions |= USE_PAD_CHAR;
+             if (trim)
+                m_padCharOptions |= TRIM_PAD_CHAR;
+        }
+    }
+    
+    /* When ft_string or ft_wstring, fill by pad char at write. */
+    inline bool isUsePadChar() const {return (m_padCharOptions & USE_PAD_CHAR) == USE_PAD_CHAR;}
+
+    /* When ft_string or ft_wstring or ft_mychar or  ft_mywchar,
+       remove pad char at read.*/
+    inline bool isTrimPadChar() const {return (m_padCharOptions & TRIM_PAD_CHAR) == TRIM_PAD_CHAR;}
+
+    inline bool isNullable() const {return (m_options & FIELD_OPTION_NULLABLE) == FIELD_OPTION_NULLABLE;}
+
+    void setNullable(bool v, bool defaultNull = true)
+    {
+        if (v)
+        {
+            m_options |= FIELD_OPTION_NULLABLE;
+            enableFlags.bitF = defaultNull;
+        }
+        else
+        {
+            m_options &= ~FIELD_OPTION_NULLABLE;
+            enableFlags.bitF = false;
+        }
+    }
+
+    void setTimeStampOnUpdate(bool v)
+    {
+        if (type == ft_mytimestamp || type == ft_mydatetime)
+            m_defValue[7] =  v ? 1: 0;
+    }
+
+    bool isTimeStampOnUpdate() const 
+    { 
+        if (type == ft_mytimestamp || type == ft_mydatetime)
+            return (m_defValue[7] == 1);
+        return false;
+    }
+
+    inline bool isDefaultNull() const
+    {
+        return enableFlags.bitF;
+    }
+
+    inline bool isLegacyTimeFormat() const
+    {
+        return (m_options & FIELD_OPTION_REGACY_TIME) != 0;
+    }
+
+    inline uint_td blobLenBytes() const
+    {
+        if (isBlob())
+            return len - 8;
+        return 0;
+    }
+
     /* length bytes of var field
      */
-    inline int varLenBytes() const
+    inline uint_td varLenBytes() const
     {
         if (((type >= ft_myvarchar) && (type <= ft_mywvarbinary)) ||
             type == ft_lstring)
@@ -411,16 +702,30 @@ public:
         return 0;
     }
 
-    inline uint_td blobLenBytes() const
+    bool operator==(const fielddef& r) const;
+
+private:
+    const char* defaultValue_strA(char* p, size_t size) const;
+    /* data length
+     */
+    inline uint_td dataLen(const uchar_td* ptr) const
     {
-        if ((type == ft_myblob) || (type == ft_mytext))
-            return len - 8;
-        return 0;
+        int blen = varLenBytes();
+        if (blen == 0)
+            return len;
+        else if (blen == 1)
+            return *((unsigned char*)ptr);
+        return *((unsigned short*)ptr);
     }
 
-    inline bool isBlob() const 
+    inline uint_td blobDataLen(const uchar_td* ptr) const
     {
-        return (type == ft_myblob) || (type == ft_mytext);
+        int blen = blobLenBytes();
+        if (blen == 0)
+            return len;
+        uint_td v = 0;
+        memcpy(&v, ptr, blen);
+        return v;
     }
 
     inline int maxVarDatalen() const
@@ -430,7 +735,7 @@ public:
             return (len < 256) ? len - 1 : len - 2;
         else if (type == ft_lvar)
             return len - 4;
-        else if ((type == ft_myblob) || (type == ft_mytext))
+        else if (isBlob())
         {
             switch (len - 8)
             {
@@ -448,34 +753,12 @@ public:
         return 0;
     }
 
-    /* data length
-     */
-    inline uint_td dataLen(const uchar_td* ptr) const
-    {
-        int blen = varLenBytes();
-        if (blen == 0)
-            return len;
-        else if (blen == 1)
-            return *((unsigned char*)ptr);
-        return *((unsigned short*)ptr);
-    }
-
-    inline uint_td blobDataLen(const uchar_td* ptr) const
-    {
-        int blen = blobLenBytes();
-        if (blen == 0)
-            return len;
-        uint_td v = 0;
-        memcpy(&v, ptr, blen);
-        return v;
-    }
-
     /* data image for key
      * param ptr address of record buffer
      */
     inline const uchar_td* keyData(const uchar_td* ptr) const
     {
-        if ((type == ft_myblob) || (type == ft_mytext))
+        if (isBlob())
             return blobDataPtr(ptr);
         int sizeByte = varLenBytes();
         return ptr + sizeByte;
@@ -483,68 +766,63 @@ public:
 
     inline uint_td keyDataLen(const uchar_td* ptr) const
     {
-        if ((type == ft_myblob) || (type == ft_mytext))
+        if (isBlob())
             return blobDataLen(ptr);
         return dataLen(ptr);
     }
 
-	inline void setPadCharSettings(bool set, bool trim)
+    /* Is variable key type
+     */
+    inline bool isKeyVarType() const
     {
-        m_padCharOptions = 0;
-        m_padCharOptions |= PAD_CHAR_OPTION_SAVED;
-        if ((type == ft_mychar) || (type == ft_mywchar))
-        {
-            m_padCharOptions |= USE_PAD_CHAR;
-            if (trim)
-                m_padCharOptions |= TRIM_PAD_CHAR;
-        }    // For compatibility with conventional.
-        else if ((type == ft_string) || (type == ft_wstring))
-        {
-             if (set)
-                m_padCharOptions |= USE_PAD_CHAR;
-             if (trim)
-                m_padCharOptions |= TRIM_PAD_CHAR;
-        }
+        return (((type >= ft_myvarchar) && (type <= ft_mywvarbinary)) || isBlob());
     }
-	
-	/* When ft_string or ft_wstring, fill by pad char at write. */
-    bool usePadChar() const {return (m_padCharOptions & USE_PAD_CHAR) == USE_PAD_CHAR;}
-
-    /* When ft_string or ft_wstring or ft_mychar or  ft_mywchar,
-       remove pad char at read.*/
-    bool trimPadChar() const {return (m_padCharOptions & TRIM_PAD_CHAR) == TRIM_PAD_CHAR;}
 
+    /* max key segment length. not include sizeBytes.
+     */
+    inline ushort_td maxKeylen() const { return keylen ? keylen : len; };
 
-/** @cond INTERNAL */
-    /* copy key data for send to mysql
+    /* copy key data for send to mysql and btrv
      *  return next copy address.
      *  If datalen==0xff then From is field formated (string) type.
      *  If datalen!=0xff then From is none field formated (string) type.
      */
-    inline uchar_td* keyCopy(uchar_td* to, const uchar_td* from, ushort_td datalen=0xff)
+    inline uchar_td* keyCopy(uchar_td* to, const uchar_td* from, ushort_td datalen,
+                     bool isNull)
     {
+        ushort_td keylen = maxKeylen(); // size of max key segmnet for mysql
+        ushort_td keyVarlen = varLenByteForKey(); // size of var sizeByte for record.
+        ushort_td copylen = std::min<ushort_td>(keylen, datalen);
 
-        ushort_td kl = maxKeylen(); // size of max key segmnet for mysql
-        memset(to, 0x00, kl);
-        ushort_td keyVarlen =
-            varLenByteForKey(); // size of var sizeByte for record.
-        ushort_td copylen = std::min<ushort_td>(kl, datalen);
-        if (keyVarlen)
+        memset(to, 0x00, keylen + 1); //clear plus null byte
+        if (isNullable())
         {
-            if (datalen==0xff)
-                copylen = (ushort_td)std::min<uint_td>((uint_td)copylen,
-                                                   keyDataLen(from));
-            // Var size is allways 2byte for key.
-            memcpy(to, &copylen, 2);
-            to += 2;
-            if (datalen==0xff)
-                from = keyData(from);
+            // mysql only
+            if (isNull)
+            {
+                *to = 1;
+                return to + 1 + keylen - keyVarlen;
+            }else
+                ++to;
         }
-        memcpy(to, from, copylen);
-        return to + kl - keyVarlen;// incremnt 2 +  (store_len - varlen)
+        if(!isNull)
+        {
+            if (keyVarlen)
+            {
+                if (datalen==0xff)
+                    copylen = (ushort_td)std::min<uint_td>((uint_td)copylen,
+                                                       keyDataLen(from));
+                // Var size is allways 2byte for key.
+                memcpy(to, &copylen, 2);
+                to += 2;
+                if (datalen==0xff)
+                    from = keyData(from);
+            }
+            memcpy(to, from, copylen);
+        }
+        return to + keylen - keyVarlen;// incremnt 2 +  (store_len - varlen)
     }
 
-
     inline const uchar_td* blobDataPtr(const uchar_td* ptr) const
     {
         int blen = blobLenBytes();
@@ -572,7 +850,7 @@ public:
         if (((type >= ft_myvarchar) && (type <= ft_mywvarbinary)) ||
             (type == ft_lstring))
             return len < 256 ? 1 : 2;
-        else if ((type == ft_myblob) || (type == ft_mytext))
+        else if (isBlob())
             return len - 8;
         return 0;
     }
@@ -626,7 +904,7 @@ public:
 
     inline void setPadCharDefaultSettings()
     {
-        if (!padCharOptionSaved())
+        if (!isPadCharOptionSaved())
         {
             // For compatibility with conventional.
             if ((type == ft_string) || (type == ft_wstring) ||
@@ -640,37 +918,153 @@ public:
             m_padCharOptions |= USE_PAD_CHAR;
     }
 
-    /* PadChar options are saved at schema.
+
    /* PadChar options are saved at schema.
         This is for compatibility with conventional.*/
-    bool padCharOptionSaved() const
+    bool isPadCharOptionSaved() const
     {
         return (m_padCharOptions & PAD_CHAR_OPTION_SAVED) == PAD_CHAR_OPTION_SAVED;
     }
+#ifdef SP_SCOPE_FIELD_TEST
+public:
+#endif
+    inline uchar_td nullbit() const {return m_nullbit;} // bit number for null indicator
+    inline uchar_td nullbytes() const {return m_nullbytes;} // byte of null indicator which head of record memory block.
+    inline void setOptions(uchar_td v) {m_options = v;}
+private:
 
-/** @endcond */
-};
+    /** Length of compare
+     * if part of string or zstring then return strlen * sizeof(char or wchar).
+     */
+    inline uint_td compDataLen(const uchar_td* ptr, bool part) const
+    {
+        uint_td length = keyDataLen(ptr);
+        if (part)
+        {
+            if ((type == ft_string) || (type == ft_zstring) ||
+                            (type == ft_note) || (type == ft_mychar))
+                length = (uint_td)strlen((const char*)ptr);
+            else if ((type == ft_wstring) || (type == ft_wzstring) ||
+                            (type == ft_mywchar))
+                length = (uint_td)strlen16((char16_t*)ptr)*sizeof(char16_t);
+        }
+        return length;
+    }
+    
+    short synchronize(const fielddef* td);
+
+    void fixCharnum_bug();
+
+    friend class client::database;
+    friend class client::dbdef;
+    friend class client::field;
+    friend class client::fields;
+    friend class client::recordCache;
+    friend class client::fielddefs;
+    friend class client::memoryRecord;
+    friend class client::filter;
+    friend class client::table;
+    friend struct client::logic;
+    friend class client::recordsetQuery;
+    friend class client::sqlBuilder;
+    friend class mysql::schemaBuilder;
+    friend struct tabledef;
 
-namespace client
+/** @cond INTERNAL */
+    friend uint_td dataLen(const fielddef& fd, const uchar_td* ptr);
+    friend uint_td blobDataLen(const fielddef& fd, const uchar_td* ptr);
+    friend uint_td blobLenBytes(const fielddef& fd);
+/** @endcond */
+};
+
+/** @cond INTERNAL */
+inline void updateTimeStampStr(const fielddef* fd, char* p, size_t size)
 {
-class dbdef;
-}
+    if (fd->isLegacyTimeFormat())
+        sprintf_s(p, 64, " ON UPDATE CURRENT_TIMESTAMP");
+    else
+        sprintf_s(p, 64, " ON UPDATE CURRENT_TIMESTAMP(%d)", fd->decimals);
+}
+
+#ifdef _WIN32
+inline void updateTimeStampStr(const fielddef* fd, wchar_t* p, size_t size)
+{
+    if (fd->isLegacyTimeFormat())
+        swprintf_s(p, 64, L" ON UPDATE CURRENT_TIMESTAMP");
+    else
+    {
+        int dec = (fd->type == ft_mytimestamp) ? (fd->len - 4) * 2 : (fd->len - 5) * 2;
+        swprintf_s(p, 64, L" ON UPDATE CURRENT_TIMESTAMP(%d)",dec);
+    }
+}
+#endif
+
+inline uint_td dataLen(const fielddef& fd, const uchar_td* ptr)
+{
+    return fd.dataLen(ptr);
+}
+
+inline uint_td blobDataLen(const fielddef& fd, const uchar_td* ptr)
+{
+    return fd.blobDataLen(ptr);
+}
+
+inline uint_td blobLenBytes(const fielddef& fd)
+{
+    return fd.blobLenBytes();
+}
+
+inline _TCHAR* timeStampDefaultStr(const fielddef& fd, _TCHAR* buf, size_t bufsize)
+{
+    if (fd.type == ft_mytimestamp || fd.type == ft_mydatetime)
+    {
+        buf[0] = 0x00;
+        if (fd.isLegacyTimeFormat())
+            _stprintf_s(buf, bufsize, _T("CURRENT_TIMESTAMP"));
+        else
+            _stprintf_s(buf, bufsize, _T("CURRENT_TIMESTAMP(%d)"), fd.decimals);
+    }
+    return buf;
+}
+
+
+/** @endcond */
+
+#define FORMAT_VERSON_BTRV_DEF 0
+#define FORMAT_VERSON_CURRENT 1
+
 
 /* Mark of ** that BizStation Corp internal use only.
  */
 struct PACKAGE tabledef
 {
     friend class client::dbdef; // for formatVersion
-
-    tabledef() { cleanup(); }
-
+    friend class client::table; // for inUse
+    friend class client::database; // for m_mysqlNullMode
+    friend struct client::openTablePrams;
+    friend struct client::dbdimple;
+    friend class client::filter;
+    friend class client::recordCache;
+    friend class client::fielddefs;
+    friend class client::sqlBuilder;
+    friend class mysql::schemaBuilder;
+
+
+    tabledef() 
+    {
+        cleanup(); 
+    }
     void cleanup()
     {
         memset(this, 0, sizeof(tabledef));
-        formatVersion = 1;
+        formatVersion = FORMAT_VERSON_CURRENT;
         primaryKeyNum = -1;
         parentKeyNum = -1;
         replicaKeyNum = -1;
         pageSize = 2048;
+        schemaCodePage = 65001;//CP_UTF8
+
+        // set temp server version
+        m_useInMariadb = true;
     }
 
 #ifdef _UNICODE
@@ -678,8 +1072,8 @@ struct PACKAGE tabledef
     const wchar_t* tableName() const; // table name
     void setFileName(const wchar_t* s);
     void setTableName(const wchar_t* s);
-    const char* toChar(char* buf, const wchar_t* s, int size);
-
+private:
+    const char* toChar(char* buf, const wchar_t* s, int size) const;
 #else
 #ifdef MYSQL_DYNAMIC_PLUGIN
 
@@ -690,8 +1084,8 @@ struct PACKAGE tabledef
     inline void setFileName(const char* s) { setFileNameA(s); };
 
     inline void setTableName(const char* s) { setTableNameA(s); };
-
-    inline const char* toChar(char* buf, const char* s, int size)
+private:
+    inline const char* toChar(char* buf, const char* s, int size) const
     {
         strncpy_s(buf, size, s, size - 1);
         return buf;
@@ -701,10 +1095,11 @@ struct PACKAGE tabledef
     const char* tableName() const;
     void setFileName(const char* s);
     void setTableName(const char* s);
-    const char* toChar(char* buf, const char* s, int size);
+private:
+    const char* toChar(char* buf, const char* s, int size) const;
 #endif // MYSQL_DYNAMIC_PLUGIN
 #endif
-
+public:
     const char* fileNameA() const { return m_fileName; };
 
     const char* tableNameA() const { return m_tableName; };
@@ -719,9 +1114,77 @@ struct PACKAGE tabledef
         strncpy_s(m_tableName, TABLE_NAME_SIZE, s, sizeof(m_tableName) - 1);
     }
 
+    inline uchar_td nullfields() const { return m_nullfields;}
+
+    inline uchar_td nullbytes() const { return m_nullbytes; }
+
+    inline uchar_td inUse() const { return m_inUse; }
+
+    int size() const;
+    short fieldNumByName(const _TCHAR* name) const;
+
+    inline ushort_td recordlen() const { return m_maxRecordLen; }
+
     uint_td unPack(char* ptr, size_t size) const;
+
+    inline void setValidationTarget(bool isMariadb, uchar_td srvMinorVersion)
+    {
+        m_useInMariadb = isMariadb;
+        m_srvMinorVer = srvMinorVersion;
+    }
+
+    inline bool isMysqlNullMode() const { return m_mysqlNullMode; }
+
+    inline bool isLegacyTimeFormat(const fielddef& fd) const
+    {
+        if (fd.type == ft_mytime || fd.type == ft_mydatetime ||
+                            fd.type == ft_mytimestamp)
+        {
+            if (m_useInMariadb)
+            {
+                if (fd.decimals == 0 && (m_srvMinorVer == 5 || m_srvMinorVer == 0)) return true;
+            }
+            else
+            {
+                if (m_srvMinorVer < 6) return true;
+            }
+        }
+        return false;
+    }
+    bool operator==(const tabledef& r) const;
+
+private:
+    short synchronize(const tabledef* td);
+    bool isNullKey(const keydef& key) const;
     uint_td pack(char* ptr, size_t size) const;
+    short findKeynumByFieldNum(short fieldNum) const;
+    inline ushort_td recordlenServer() const
+    {
+        if (optionFlags.bitC) return m_maxRecordLen + 2;
+        return m_maxRecordLen;
+    }
+    bool isNeedNis(const keydef& key) const;
+    bool isNULLFieldFirstKeySegField(const keydef& key) const;
+    bool isNullValueZeroAll(const keydef& key) const;
+    void setMysqlNullMode(bool v);
+    void calcReclordlen(bool force= false);
+    inline keydef* setKeydefsPtr()
+    {
+        return keyDefs = (keydef*)((char*)this + sizeof(tabledef) +
+                         (fieldCount * sizeof(fielddef)));
+    }
 
+    inline fielddef* setFielddefsPtr()
+    {
+        return fieldDefs = (fielddef*)((char*)this + sizeof(tabledef));
+    }
+
+    inline bool isMariaTimeFormat() const
+    {
+        return (m_useInMariadb && (m_srvMajorVer == 5 || m_srvMinorVer == 0));
+    }
+
+public:
     ushort_td id; // table id
 
 #ifdef SWIG
@@ -748,16 +1211,27 @@ private:
     char m_tableName[TABLE_NAME_SIZE];
 
 public:
-    short version; // table version
-    uchar_td charsetIndex; // SCHARSET_INFO vector index;
-    uchar_td filler0[17]; // reserved
+    short version;            // table version
+    uchar_td charsetIndex;    // SCHARSET_INFO vector index;
+private:
+    uchar_td m_nullfields;    // number of nullable field
+    uchar_td m_nullbytes;     // number of null indicator byte
+    uchar_td m_inUse;
+    bool m_mysqlNullMode ;    // use in mysqlnull mode
+    bool m_useInMariadb  ;    // use in mariadb
+    uchar_td m_srvMajorVer;   // server major version;
+    uchar_td m_srvMinorVer;   // server minor version;
+    uchar_td m_filler0[10];   // reserved
+public:
     FLAGS flags; // file flags
     uchar_td primaryKeyNum; // Primary key number. -1 is no primary.
     uchar_td parentKeyNum; // ** Key number for listview. -1 is no use.
     uchar_td replicaKeyNum; // ** Key number for repdata. -1 is no use.
     FLAGS optionFlags; // ** optional flags
     ushort_td convertFileNum; // ** not use
-    ushort_td maxRecordLen; // max record length of var size table.
+private:
+    ushort_td m_maxRecordLen; // max record length of var size table.
+public:
     uchar_td treeIndex; // ** View index for listview.
     uchar_td iconIndex; // ** Icon index for listview.
     ushort_td ddfid;
@@ -769,15 +1243,18 @@ public:
 
 private:
     char formatVersion;
-
-public:
     client::dbdef* parent;
+    void* defaultImage;
     uchar_td reserved[TABLEDEF_FILLER_SIZE]; // reserved
-
+public:
     fielddef* fieldDefs; // Pointer cahche of first field.
     keydef* keyDefs; // Pointer cahche of first key.
 };
 
+// sizeof(fielddef) * 255 + sizeof(keydef) * 64 + sizeof(tabledef)
+// (124 * 255) + (26 * 64) + 388 = 31620 + 1664 + 388 = 33672 
+#define MAX_SCHEMASIZE  33672 
+
 /* optionFlags   BizStation internal use only.
  Bit0 send windows messege.
  Bit1 show tree view.
@@ -791,6 +1268,7 @@ public:
  Bit9 Can export this table.
  BitA is this table include valiable fields (varchar or varbinary is used)
  BitB is this table include blob field (Blob is used)
+ BitC is this table include fixedbinary
  */
 
 struct PACKAGE btrVersion
@@ -801,6 +1279,33 @@ struct PACKAGE btrVersion
 
     const _TCHAR* moduleVersionShortString(_TCHAR* buf);
     const _TCHAR* moduleTypeString();
+
+    inline bool isSupportDateTimeTimeStamp() const
+    {
+        if (majorVersion >= 10) return true;
+        if ((majorVersion == 5) && (minorVersion > 5)) return true;
+        return false;
+    }
+
+    inline bool isSupportMultiTimeStamp() const
+    {
+        return isSupportDateTimeTimeStamp();
+    }
+
+    inline bool isMariaDB() const { return type == MYSQL_TYPE_MARIA; }
+
+    inline bool isMysql56TimeFormat() const 
+    {
+        if ((majorVersion == 10) && (minorVersion >= 1)) return true;
+        if ((majorVersion == 5) && (minorVersion >= 6)) return true;
+        return false;
+    }
+
+    inline bool isFullLegacyTimeFormat() const 
+    {
+        return !isMariaDB() && (minorVersion < 6);
+    }
+
 };
 
 struct btrVersions
@@ -808,29 +1313,16 @@ struct btrVersions
     btrVersion versions[4];
 };
 
+#define VER_IDX_CLINET    0
+#define VER_IDX_DB_SERVER 1
+#define VER_IDX_PLUGIN    2
+
+
+
+
 #pragma pack(pop)
 pragma_pop;
 
-/* filter cobine type */
-enum combineType
-{
-    eCend,
-    eCand,
-    eCor
-};
-
-/* compair types */
-enum eCompType
-{
-    eEqual = 1,
-    eGreater = 2,
-    eLess = 3,
-    eNotEq = 4,
-    eGreaterEq = 5,
-    eLessEq = 6,
-    eBitAnd = 8,
-    eNotBitAnd = 9
-};
 
 PACKAGE uchar_td getFilterLogicTypeCode(const _TCHAR* cmpstr);