transactd 2.3.0 → 2.4.0

data/source/bzs/db/protocol/tdap/client/trdboostapi.h

@@ -878,9 +878,13 @@ template <class Database_Ptr> inline void dropDatabase(Database_Ptr db)
 }
 
 template <class Database_Ptr>
-inline table_ptr openTable(Database_Ptr db, const _TCHAR* name, short mode = TD_OPEN_NORMAL)
+inline table_ptr openTable(Database_Ptr db, const _TCHAR* name,
+        short mode = TD_OPEN_NORMAL,
+        bool autoCreate = true, const _TCHAR* ownerName = NULL,
+                     const _TCHAR* uri = NULL)
 {
-    table_ptr p(db->openTable(name, mode), releaseTable);
+    table_ptr p(db->openTable(name, mode, autoCreate, ownerName, uri),
+                releaseTable);
     if (db->stat())
         nstable::throwError((std::_tstring(_T("Open table ")) + name).c_str(),
                             db->stat());
@@ -888,9 +892,14 @@ inline table_ptr openTable(Database_Ptr db, const _TCHAR* name, short mode = TD_
 }
 
 template <class Database_Ptr>
-inline table_ptr openTable(Database_Ptr db, short tableid, short mode = TD_OPEN_NORMAL)
+inline table_ptr openTable(Database_Ptr db, short tableid,
+        short mode = TD_OPEN_NORMAL,
+        bool autoCreate = true, const _TCHAR* ownerName = NULL,
+                     const _TCHAR* uri = NULL)
 {
-    table_ptr p(db->openTable(tableid, mode), releaseTable);
+    table_ptr p(db->openTable(tableid, mode, autoCreate, ownerName, uri),
+                releaseTable);
+
     if (db->stat())
     {
         _TCHAR buf[50];
@@ -952,6 +961,23 @@ inline void insertTable(dbdef* def, short id, const _TCHAR* name,
             def->stat());
 }
 
+inline void deleteTable(dbdef* def, short id)
+{
+    def->deleteTable(id);
+    if (def->stat() != 0)
+        nstable::throwError(_T("Delete tabledef "), def->stat());
+
+}
+
+
+inline void renumberTable(dbdef* def, short id, short newid)
+{
+    def->renumberTable(id, newid);
+    if (def->stat() != 0)
+        nstable::throwError(_T("Renumber table id "), def->stat());
+
+}
+
 inline fielddef* insertField(dbdef* def, short tableid, short fieldNum,
                              const _TCHAR* name, uchar_td type, ushort_td len)
 {
@@ -967,6 +993,13 @@ inline fielddef* insertField(dbdef* def, short tableid, short fieldNum,
     return fd;
 }
 
+inline void deleteField(dbdef* def, short tableid, short fieldNum)
+{
+    def->deleteField(tableid, fieldNum);
+    if (def->stat() != 0)
+        nstable::throwError(_T("Delete fielddef "), def->stat());
+}
+
 inline keydef* insertKey(dbdef* def, short tableid, short insertIndex)
 {
     keydef* kd = def->insertKey(tableid, insertIndex);
@@ -976,6 +1009,26 @@ inline keydef* insertKey(dbdef* def, short tableid, short insertIndex)
     return kd;
 }
 
+inline void deleteKey(dbdef* def, short tableid, short keynum)
+{
+    def->deleteKey(tableid, keynum);
+    if (def->stat() != 0)
+        nstable::throwError(_T("Delete keydef "), def->stat());
+}
+
+inline void validateTableDef(dbdef* def, short tableid)
+{
+    def->validateTableDef(tableid);
+    if (def->stat() != 0)
+    {
+        std::_tstring s;
+        if (def->tableDefs(tableid))
+            s = def->tableDefs(tableid)->tableName();
+        nstable::throwError((std::_tstring(_T("Validate tabledef ")) + s).c_str(),
+                            def->stat());
+    }
+}
+
 inline void updateTableDef(dbdef* def, short tableid)
 {
     def->updateTableDef(tableid);

data/source/bzs/db/protocol/tdap/client/trdormapi.h

@@ -323,13 +323,31 @@ class activeObject : boost::noncopyable
         m_tb = mgr->table(name);
     }
 
-    void init(database_ptr& db, const _TCHAR* name)
+    void init(database_ptr& db, const _TCHAR* name, short mode)
     {
-        m_tb = openTable(db, name);
+        m_tb = openTable(db, name, mode);
+    }
+
+    void init(database* db, const _TCHAR* name, short mode)
+    {
+        m_tb = openTable(db, name, mode);
+    }
+
+    /*void init(idatabaseManager* mgr, short tableindex)
+    {
+        m_tb = mgr->table(tableindex);
+    }*/
+
+    void init(database_ptr& db, short tableindex, short mode)
+    {
+        m_tb = openTable(db, tableindex, mode);
+    }
+
+    void init(database* db, short tableindex, short mode)
+    {
+        m_tb = openTable(db, tableindex, mode);
     }
 
-    void init(database* db, const _TCHAR* name) { m_tb = openTable(db, name); }
-    
     void prepare(const pq_handle& q)
     {
         m_tb->setPrepare(q);
@@ -353,10 +371,10 @@ public:
             initFdi(m_fdi, m_tb.get());
     }
 
-    explicit activeObject(database_ptr& db)
+    explicit activeObject(database_ptr& db, short mode = TD_OPEN_NORMAL)
         : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
     {
-        init(db, m_map.getTableName());
+        init(db, m_map.getTableName(), mode);
         if (table() && m_fdi)
             initFdi(m_fdi, m_tb.get());
     }
@@ -369,29 +387,46 @@ public:
             initFdi(m_fdi, m_tb.get());
     }
 
-    /*explicit activeObject(dbmanager_ptr& mgr, const _TCHAR* tableName)
-            :m_option(0)
-            ,m_fdi(createFdi(m_fdi))
-            ,m_map(*m_fdi)
-            {
-                    init(mgr, tableName);
-                    if (table() && m_fdi)
-                            initFdi(m_fdi, m_tb.get());
-            }
-     */
+    /*explicit activeObject(idatabaseManager* mgr, short tableIndex)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(mgr, tableIndex);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }*/
+
+    explicit activeObject(database_ptr& db, const _TCHAR* tableName,
+                                         short mode = TD_OPEN_NORMAL)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(db, tableName, mode);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }
+
+    explicit activeObject(database* db, const _TCHAR* tableName,
+                                         short mode = TD_OPEN_NORMAL)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(db, tableName, mode);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }
 
-    explicit activeObject(database_ptr& db, const _TCHAR* tableName)
+    explicit activeObject(database_ptr& db, short tableIndex,
+                                         short mode = TD_OPEN_NORMAL)
         : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
     {
-        init(db, tableName);
+        init(db, tableIndex, mode);
         if (table() && m_fdi)
             initFdi(m_fdi, m_tb.get());
     }
 
-    explicit activeObject(database* db, const _TCHAR* tableName)
+    explicit activeObject(database* db, short tableIndex,
+                                         short mode = TD_OPEN_NORMAL)
         : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
     {
-        init(db, tableName);
+        init(db, tableIndex, mode);
         if (table() && m_fdi)
             initFdi(m_fdi, m_tb.get());
     }

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

@@ -66,26 +66,6 @@ uint_td copyToRecordImage(uchar* rec, void* p, uint_td size, uint_td offset)
     return offset + size;
 }
 
-bool isStringType(char type)
-{
-    switch (type)
-    {
-    case ft_zstring:
-    case ft_string:
-    case ft_mychar:
-    case ft_myvarchar:
-    case ft_myvarbinary:
-    case ft_wzstring:
-    case ft_wstring:
-    case ft_mywchar:
-    case ft_mywvarchar:
-    case ft_mywvarbinary:
-        return true;
-    default:
-        return false;
-    }
-}
-
 uchar_td convFieldType(enum enum_field_types type, uint flags, bool binary,
                        bool unicode)
 {
@@ -226,7 +206,7 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
                 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 (isStringType(convFieldType(
+                if (isStringTypeForIndex(convFieldType(
                         src->fieldType(sg.fieldNum),
                         src->fieldFlags(sg.fieldNum),
                         isBinary(src->fieldCharset(i)),
@@ -252,10 +232,10 @@ short schemaBuilder::insertMetaRecord(table* mtb, table* src, int id)
     return mtb->stat();
 }
 
-bool isFrmFile(const std::string& name)
+bool isFrmFile(const std::string& name, bool notschema=true)
 {
     size_t pos = name.find(TRANSACTD_SCHEMANAME);
-    if (pos != std::string::npos)
+    if (pos != std::string::npos && notschema)
         return false;
     // First of name is '#' that is alter table temp file.
     if (name.size() && name[0] == '#')
@@ -266,6 +246,48 @@ bool isFrmFile(const std::string& name)
     return false;
 }
 
+void schemaBuilder::listSchemaTable(database* db, std::vector<std::string>& shcemaNames)
+{
+    char path[FN_REFLEN + 1];
+    build_table_filename(path, sizeof(path) - 1, db->name().c_str(), "", "", 0);
+    std::string s = path;
+    fs::path p = s;
+    fs::directory_iterator it(p);
+    fs::directory_iterator end;
+    shcemaNames.clear();
+    
+    for (fs::directory_iterator it(p); it != end; ++it)
+    {
+        if (!is_directory(*it))
+        {
+            std::string s = it->path().filename().string();
+            if (isFrmFile(s, false))
+            {
+                filename_to_tablename(it->path().stem().string().c_str(), path,
+                                      FN_REFLEN);
+                table* tb = NULL;
+                try
+                {
+                    tb = db->openTable(path, TD_OPEN_READONLY, NULL);
+                }
+                catch(...){}
+                if (!tb) break;
+                if (!tb->isView())
+                {
+                    LEX_STRING& comment = tb->internalTable()->s->comment; 
+                    const char* p = comment.str;
+                    if ((comment.length > 8) && strstr(p,"%@%02.000") &&              
+                        (tb->fields() == 2) && (tb->keys() == 1))
+                    {
+                        shcemaNames.push_back(tb->name());    
+                    }
+                }
+                db->closeTable(tb);
+            }
+        }
+    }
+}
+
 short schemaBuilder::execute(database* db, table* mtb)
 {
     char path[FN_REFLEN + 1];
@@ -277,7 +299,8 @@ short schemaBuilder::execute(database* db, table* mtb)
     fs::directory_iterator end;
     int id = 0;
     short stat = 0;
-    smartTransction trn(db);
+    std::vector<table*> tables;
+    
     for (fs::directory_iterator it(p); it != end; ++it)
     {
         if (!is_directory(*it))
@@ -288,17 +311,28 @@ short schemaBuilder::execute(database* db, table* mtb)
                 filename_to_tablename(it->path().stem().string().c_str(), path,
                                       FN_REFLEN);
                 table* tb = db->openTable(path, TD_OPEN_READONLY, NULL);
-                if (!tb)
-                    return db->stat();
+                if (!tb) break;
                 if (!tb->isView())
-                {
-                    if ((stat = insertMetaRecord(mtb, tb, ++id)) != 0)
-                        return stat;
-                }
+                    tables.push_back(tb);
+                else
+                    db->closeTable(tb);
             }
         }
     }
-    trn.end();
+    if (db->stat()) return db->stat();
+
+    {
+        smartTransction trn(db);
+        for (size_t i = 0; i < tables.size(); ++i)
+        {
+            if ((stat = insertMetaRecord(mtb, tables[i], ++id)) != 0)
+                    break;
+        }
+        if (stat == 0) trn.end();
+            
+    }
+    for (size_t i = 0; i < tables.size(); ++i)
+        db->closeTable(tables[i]);
     return stat;
 }
 

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

@@ -21,6 +21,7 @@
 
 #include <bzs/db/protocol/tdap/tdapSchema.h>
 #include <string>
+#include <vector>
 
 namespace bzs
 {
@@ -52,6 +53,7 @@ public:
     schemaBuilder();
     ~schemaBuilder();
     short execute(engine::mysql::database* db, engine::mysql::table* mtb);
+    static void listSchemaTable(engine::mysql::database* db, std::vector<std::string>& shcemaNames);
 };
 
 } // namespace mysql

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

@@ -691,9 +691,10 @@ public:
                     bool valid = !(forword ? gt : le);
                     
                     // case in-sencitive, Index judge need clinet and server are same option.
-                    bool is_cl = ((fd->logType & CMPLOGICAL_CASEINSENSITIVE) != 0);
-                    bool is_srv = ((key->key_part[segmentIndex].field->flags & BINARY_FLAG) == 0);
-                    if (valid && (is_cl == is_srv))
+                    bool is_cl_casein = ((fd->logType & CMPLOGICAL_CASEINSENSITIVE) != 0);
+                    bool is_srv_casein = ((key->key_part[segmentIndex].field->flags & BINARY_FLAG) == 0) && 
+                                            isStringType(fd->type);
+                    if (valid && (is_cl_casein == is_srv_casein))
                     {
                         m_keySeg = (unsigned char)segmentIndex + 1;
                         m_judgeType = (comp == eEqual) ? 2 : 1;
@@ -950,7 +951,7 @@ class resultWriter
     const extResultDef* m_def;
     bool m_noBookmark;
 
-    short doWrite(position* pos, unsigned int bookmark)
+    short doWrite(position* pos, const unsigned char* bookmark, int bmlen)
     {
         // write recLength space;
         unsigned short recLen = 0;
@@ -959,7 +960,7 @@ class resultWriter
 
         // write bookmark
         if (!m_noBookmark)
-            m_nw->asyncWrite((const char*)&bookmark, 4);
+            m_nw->asyncWrite((const char*)bookmark, bmlen);
 
         // if pos ==NULL , that is not found record in a TD_KEY_SEEK_MULTI
         // operation
@@ -1010,6 +1011,7 @@ class resultWriter
     }
 
 public:
+    resultWriter() : m_nw(NULL), m_def(NULL){}
 
     void init(netsvc::server::netWriter* nw, const extResultDef* def,
                  bool noBookmark)
@@ -1019,15 +1021,19 @@ public:
          m_noBookmark = noBookmark;
     }
 
-    short write(position* pos, unsigned int bookmark)
+    short write(position* pos, const unsigned char* bookmark, int len)
     {
-        return doWrite(pos, bookmark);
+        return doWrite(pos, bookmark, len);
     }
 
     inline unsigned int end()
     {
-        m_nw->asyncWrite(NULL, 0, netsvc::server::netWriter::writeEnd);
-        return m_nw->resultLen();
+        if (m_nw)
+        {
+            m_nw->asyncWrite(NULL, 0, netsvc::server::netWriter::writeEnd);
+            return m_nw->resultLen();
+        }
+        return 0;
     }
 
     const char* resultBuffer() { return m_nw->ptr(); }
@@ -1073,7 +1079,7 @@ public:
         if(p->readMapSize)
         {
             bm.setTable(tb);
-            if (m_seeksMode)
+            if (m_seeksMode && !(req->itype & FILTER_TYPE_SEEKS_BOOKMARKS))
                 addKeysegFieldMap(tb);
             if (p->readMapSize)
                 p->copyBitmapTo(bm.getReadBitmap());
@@ -1126,7 +1132,8 @@ public:
         if ((rd->fieldCount > 1) ||
             ((rd->fieldCount == 1) &&
              (rd->field[0].len < m_position.recordLenCl())))
-            ret = convResultPosToFieldNum(tb, noBookmark, rd, m_seeksMode);
+            ret = convResultPosToFieldNum(tb, noBookmark, rd, m_seeksMode, 
+                            (req->itype & FILTER_TYPE_SEEKS_BOOKMARKS) != 0);
 
         nw->beginExt(tb->blobFields() != 0);
         m_writer.init(nw, rd, noBookmark);
@@ -1154,7 +1161,7 @@ public:
 
     // TODO This convert is move to client. but legacy app is need this
     short convResultPosToFieldNum(engine::mysql::table* tb, bool noBookmark,
-                                  const extResultDef* rd, bool seeksMode)
+                                  const extResultDef* rd, bool seeksMode, bool seekBookmark)
     {
         int blobs = 0;
         bm.setTable(tb);
@@ -1179,7 +1186,7 @@ public:
                 fd = fd->next();
             }
         }
-        else
+        else if (!seekBookmark)
             addKeysegFieldMap(tb);
 
         // if need bookmark , add primary key fields
@@ -1220,39 +1227,20 @@ public:
         return REC_MACTH;
     }
 
-    short write(const unsigned char* bmPtr,
+    short write(const unsigned char* bookmarkPtr,
                 unsigned int bmlen /*, short stat=0*/)
     {
         unsigned int bookmark = 0;
         // if bmPtr ==NULL , that is not found record in a TD_KEY_SEEK_MULTI
         // operation
         // and set error code to bookmark also STATUS_NOT_FOUND_TI
-        if (bmPtr == NULL)
+        if (bookmarkPtr == NULL)
         {
             // bookmark = stat;
-            return m_writer.write(NULL, bookmark);
+            return m_writer.write(NULL, (const unsigned char*)&bookmark, sizeof(bookmark));
         }
         else
-        {
-            switch (bmlen)
-            {
-            case 4:
-                bookmark = *((unsigned int*)bmPtr);
-                break;
-            case 2:
-                bookmark = *((unsigned short*)bmPtr);
-                break;
-            case 3:
-                bookmark = *((unsigned int*)bmPtr) & 0x0FFFFFF;
-                break;
-            case 1:
-                bookmark = *((unsigned short*)bmPtr) & 0x0FF;
-                break;
-            default:
-                break;
-            }
-            return m_writer.write(&m_position, bookmark);
-        }
+            return m_writer.write(&m_position, bookmarkPtr, bmlen);
     }
     unsigned short rejectCount() const { return m_req->rejectCount; };
     unsigned short maxRows() const { return m_maxRows; };

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

@@ -108,7 +108,7 @@ public:
             p += TD_POSBLK_TRANSMIT_SIZE;
             if (P_MASK_PB_BOOKMARK & paramMask)
             {
-                uint v = tb->posPtrLenRaw();
+                uint v = tb->posPtrLen();
                 memcpy(p++, &v, 1);
                 memcpy(p, tb->position(true), v);
                 p += v;