开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbBlob.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：40k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbBlob.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <Ndb.hpp>
  18. #include <NdbDictionaryImpl.hpp>
  19. #include <NdbConnection.hpp>
  20. #include <NdbOperation.hpp>
  21. #include <NdbIndexOperation.hpp>
  22. #include <NdbRecAttr.hpp>
  23. #include <NdbBlob.hpp>
  24. #include "NdbBlobImpl.hpp"
  25. #include <NdbScanOperation.hpp>
  27. #ifdef NDB_BLOB_DEBUG
  28. #define DBG(x) 
  29.   do { 
  30.     static const char* p = getenv("NDB_BLOB_DEBUG"); 
  31.     if (p == 0 || *p == 0 || *p == '0') break; 
  32.     static char* prefix = "BLOB"; 
  33.     const char* cname = theColumn == NULL ? "-" : theColumn->m_name.c_str(); 
  34.     ndbout << prefix << " " << hex << (void*)this << " " << cname; 
  35.     ndbout << " " << dec << __LINE__ << " " << x << " " << *this << endl; 
  36.   } while (0)
  38. static char*
  39. ndb_blob_debug(const Uint32* data, unsigned size)
  40. {
  41.   static char buf[200]; // MT irrelevant
  42.   buf[0] = 0;
  43.   for (unsigned i = 0; i < size; i++) {
  44.     unsigned n = strlen(buf);
  45.     if (n + 10 < sizeof(buf))
  46.       sprintf(buf + n, "%*s%08x", i != 0, "", data[i]);
  47.   }
  48.   return buf;
  49. }
  51. #else
  52. #define DBG(x)
  53. #endif
  55. /*
  56.  * Reading index table directly (as a table) is faster but there are
  57.  * bugs or limitations.  Keep the code and make possible to choose.
  58.  */
  59. static const bool g_ndb_blob_ok_to_read_index_table = false;
  61. // state (inline)
  63. inline void
  64. NdbBlob::setState(State newState)
  65. {
  66.   DBG("setState " << newState);
  67.   theState = newState;
  68. }
  70. // define blob table
  72. int
  73. NdbBlob::getBlobTableName(char* btname, Ndb* anNdb, const char* tableName, const char* columnName)
  74. {
  75.   NdbTableImpl* t = anNdb->theDictionary->m_impl.getTable(tableName);
  76.   if (t == NULL)
  77.     return -1;
  78.   NdbColumnImpl* c = t->getColumn(columnName);
  79.   if (c == NULL)
  80.     return -1;
  81.   getBlobTableName(btname, t, c);
  82.   return 0;
  83. }
  85. void
  86. NdbBlob::getBlobTableName(char* btname, const NdbTableImpl* t, const NdbColumnImpl* c)
  87. {
  88.   assert(t != 0 && c != 0 && c->getBlobType());
  89.   memset(btname, 0, NdbBlobImpl::BlobTableNameSize);
  90.   sprintf(btname, "NDB$BLOB_%d_%d", (int)t->m_tableId, (int)c->m_attrId);
  91. }
  93. void
  94. NdbBlob::getBlobTable(NdbTableImpl& bt, const NdbTableImpl* t, const NdbColumnImpl* c)
  95. {
  96.   char btname[NdbBlobImpl::BlobTableNameSize];
  97.   getBlobTableName(btname, t, c);
  98.   bt.setName(btname);
  99.   bt.setLogging(t->getLogging());
  100.   bt.setFragmentType(t->getFragmentType());
  101.   { NdbDictionary::Column bc("PK");
  102.     bc.setType(NdbDictionary::Column::Unsigned);
  103.     assert(t->m_sizeOfKeysInWords != 0);
  104.     bc.setLength(t->m_sizeOfKeysInWords);
  105.     bc.setPrimaryKey(true);
  106.     bc.setDistributionKey(true);
  107.     bt.addColumn(bc);
  108.   }
  109.   { NdbDictionary::Column bc("DIST");
  110.     bc.setType(NdbDictionary::Column::Unsigned);
  111.     bc.setPrimaryKey(true);
  112.     bc.setDistributionKey(true);
  113.     bt.addColumn(bc);
  114.   }
  115.   { NdbDictionary::Column bc("PART");
  116.     bc.setType(NdbDictionary::Column::Unsigned);
  117.     bc.setPrimaryKey(true);
  118.     bc.setDistributionKey(false);
  119.     bt.addColumn(bc);
  120.   }
  121.   { NdbDictionary::Column bc("DATA");
  122.     switch (c->m_type) {
  123.     case NdbDictionary::Column::Blob:
  124.       bc.setType(NdbDictionary::Column::Binary);
  125.       break;
  126.     case NdbDictionary::Column::Text:
  127.       bc.setType(NdbDictionary::Column::Char);
  128.       break;
  129.     default:
  130.       assert(false);
  131.       break;
  132.     }
  133.     bc.setLength(c->getPartSize());
  134.     bt.addColumn(bc);
  135.   }
  136. }
  138. // initialization
  140. NdbBlob::NdbBlob(Ndb*)
  141. {
  142.   init();
  143. }
  145. void
  146. NdbBlob::init()
  147. {
  148.   theState = Idle;
  149.   theNdb = NULL;
  150.   theNdbCon = NULL;
  151.   theNdbOp = NULL;
  152.   theTable = NULL;
  153.   theAccessTable = NULL;
  154.   theBlobTable = NULL;
  155.   theColumn = NULL;
  156.   theFillChar = 0;
  157.   theInlineSize = 0;
  158.   thePartSize = 0;
  159.   theStripeSize = 0;
  160.   theGetFlag = false;
  161.   theGetBuf = NULL;
  162.   theSetFlag = false;
  163.   theSetBuf = NULL;
  164.   theGetSetBytes = 0;
  165.   thePendingBlobOps = 0;
  166.   theActiveHook = NULL;
  167.   theActiveHookArg = NULL;
  168.   theHead = NULL;
  169.   theInlineData = NULL;
  170.   theHeadInlineRecAttr = NULL;
  171.   theHeadInlineReadOp = NULL;
  172.   theHeadInlineUpdateFlag = false;
  173.   theNullFlag = -1;
  174.   theLength = 0;
  175.   thePos = 0;
  176.   theNext = NULL;
  177. }
  179. void
  180. NdbBlob::release()
  181. {
  182.   setState(Idle);
  183. }
  185. // buffers
  187. NdbBlob::Buf::Buf() :
  188.   data(NULL),
  189.   size(0),
  190.   maxsize(0)
  191. {
  192. }
  194. NdbBlob::Buf::~Buf()
  195. {
  196.   delete [] data;
  197. }
  199. void
  200. NdbBlob::Buf::alloc(unsigned n)
  201. {
  202.   size = n;
  203.   if (maxsize < n) {
  204.     delete [] data;
  205.     // align to Uint64
  206.     if (n % 8 != 0)
  207.       n += 8 - n % 8;
  208.     data = new char [n];
  209.     maxsize = n;
  210.   }
  211. #ifdef VM_TRACE
  212.   memset(data, 'X', maxsize);
  213. #endif
  214. }
  216. void
  217. NdbBlob::Buf::copyfrom(const NdbBlob::Buf& src)
  218. {
  219.   assert(size == src.size);
  220.   memcpy(data, src.data, size);
  221. }
  223. // classify operations (inline)
  225. inline bool
  226. NdbBlob::isTableOp()
  227. {
  228.   return theTable == theAccessTable;
  229. }
  231. inline bool
  232. NdbBlob::isIndexOp()
  233. {
  234.   return theTable != theAccessTable;
  235. }
  237. inline bool
  238. NdbBlob::isKeyOp()
  239. {
  240.   return
  241.     theNdbOp->theOperationType == NdbOperation::InsertRequest ||
  242.     theNdbOp->theOperationType == NdbOperation::UpdateRequest ||
  243.     theNdbOp->theOperationType == NdbOperation::WriteRequest ||
  244.     theNdbOp->theOperationType == NdbOperation::ReadRequest ||
  245.     theNdbOp->theOperationType == NdbOperation::ReadExclusive ||
  246.     theNdbOp->theOperationType == NdbOperation::DeleteRequest;
  247. }
  249. inline bool
  250. NdbBlob::isReadOp()
  251. {
  252.   return
  253.     theNdbOp->theOperationType == NdbOperation::ReadRequest ||
  254.     theNdbOp->theOperationType == NdbOperation::ReadExclusive;
  255. }
  257. inline bool
  258. NdbBlob::isInsertOp()
  259. {
  260.   return
  261.     theNdbOp->theOperationType == NdbOperation::InsertRequest;
  262. }
  264. inline bool
  265. NdbBlob::isUpdateOp()
  266. {
  267.   return
  268.     theNdbOp->theOperationType == NdbOperation::UpdateRequest;
  269. }
  271. inline bool
  272. NdbBlob::isWriteOp()
  273. {
  274.   return
  275.     theNdbOp->theOperationType == NdbOperation::WriteRequest;
  276. }
  278. inline bool
  279. NdbBlob::isDeleteOp()
  280. {
  281.   return
  282.     theNdbOp->theOperationType == NdbOperation::DeleteRequest;
  283. }
  285. inline bool
  286. NdbBlob::isScanOp()
  287. {
  288.   return
  289.     theNdbOp->theOperationType == NdbOperation::OpenScanRequest ||
  290.     theNdbOp->theOperationType == NdbOperation::OpenRangeScanRequest;
  291. }
  293. // computations (inline)
  295. inline Uint32
  296. NdbBlob::getPartNumber(Uint64 pos)
  297. {
  298.   assert(thePartSize != 0 && pos >= theInlineSize);
  299.   return (pos - theInlineSize) / thePartSize;
  300. }
  302. inline Uint32
  303. NdbBlob::getPartCount()
  304. {
  305.   if (theLength <= theInlineSize)
  306.     return 0;
  307.   return 1 + getPartNumber(theLength - 1);
  308. }
  310. inline Uint32
  311. NdbBlob::getDistKey(Uint32 part)
  312. {
  313.   assert(theStripeSize != 0);
  314.   return (part / theStripeSize) % theStripeSize;
  315. }
  317. // getters and setters
  319. int
  320. NdbBlob::getTableKeyValue(NdbOperation* anOp)
  321. {
  322.   Uint32* data = (Uint32*)theKeyBuf.data;
  323.   unsigned pos = 0;
  324.   DBG("getTableKeyValue");
  325.   for (unsigned i = 0; i < theTable->m_columns.size(); i++) {
  326.     NdbColumnImpl* c = theTable->m_columns[i];
  327.     assert(c != NULL);
  328.     if (c->m_pk) {
  329.       unsigned len = c->m_attrSize * c->m_arraySize;
  330.       if (anOp->getValue_impl(c, (char*)&data[pos]) == NULL) {
  331.         setErrorCode(anOp);
  332.         return -1;
  333.       }
  334.       // odd bytes receive no data and must be zeroed
  335.       while (len % 4 != 0) {
  336.         char* p = (char*)&data[pos] + len++;
  337.         *p = 0;
  338.       }
  339.       pos += len / 4;
  340.     }
  341.   }
  342.   assert(pos == theKeyBuf.size / 4);
  343.   return 0;
  344. }
  346. int
  347. NdbBlob::setTableKeyValue(NdbOperation* anOp)
  348. {
  349.   const Uint32* data = (const Uint32*)theKeyBuf.data;
  350.   DBG("setTableKeyValue key=" << ndb_blob_debug(data, theTable->m_sizeOfKeysInWords));
  351.   const unsigned columns = theTable->m_columns.size();
  352.   unsigned pos = 0;
  353.   for (unsigned i = 0; i < columns; i++) {
  354.     NdbColumnImpl* c = theTable->m_columns[i];
  355.     assert(c != NULL);
  356.     if (c->m_pk) {
  357.       unsigned len = c->m_attrSize * c->m_arraySize;
  358.       if (anOp->equal_impl(c, (const char*)&data[pos], len) == -1) {
  359.         setErrorCode(anOp);
  360.         return -1;
  361.       }
  362.       pos += (len + 3) / 4;
  363.     }
  364.   }
  365.   assert(pos == theKeyBuf.size / 4);
  366.   return 0;
  367. }
  369. int
  370. NdbBlob::setAccessKeyValue(NdbOperation* anOp)
  371. {
  372.   const Uint32* data = (const Uint32*)theAccessKeyBuf.data;
  373.   DBG("setAccessKeyValue key=" << ndb_blob_debug(data, theAccessTable->m_sizeOfKeysInWords));
  374.   const unsigned columns = theAccessTable->m_columns.size();
  375.   unsigned pos = 0;
  376.   for (unsigned i = 0; i < columns; i++) {
  377.     NdbColumnImpl* c = theAccessTable->m_columns[i];
  378.     assert(c != NULL);
  379.     if (c->m_pk) {
  380.       unsigned len = c->m_attrSize * c->m_arraySize;
  381.       if (anOp->equal_impl(c, (const char*)&data[pos], len) == -1) {
  382.         setErrorCode(anOp);
  383.         return -1;
  384.       }
  385.       pos += (len + 3) / 4;
  386.     }
  387.   }
  388.   assert(pos == theAccessKeyBuf.size / 4);
  389.   return 0;
  390. }
  392. int
  393. NdbBlob::setPartKeyValue(NdbOperation* anOp, Uint32 part)
  394. {
  395.   Uint32* data = (Uint32*)theKeyBuf.data;
  396.   unsigned size = theTable->m_sizeOfKeysInWords;
  397.   DBG("setPartKeyValue dist=" << getDistKey(part) << " part=" << part << " key=" << ndb_blob_debug(data, size));
  398.   // TODO use attr ids after compatibility with 4.1.7 not needed
  399.   if (anOp->equal("PK", theKeyBuf.data) == -1 ||
  400.       anOp->equal("DIST", getDistKey(part)) == -1 ||
  401.       anOp->equal("PART", part) == -1) {
  402.     setErrorCode(anOp);
  403.     return -1;
  404.   }
  405.   return 0;
  406. }
  408. int
  409. NdbBlob::getHeadInlineValue(NdbOperation* anOp)
  410. {
  411.   DBG("getHeadInlineValue");
  412.   theHeadInlineRecAttr = anOp->getValue_impl(theColumn, theHeadInlineBuf.data);
  413.   if (theHeadInlineRecAttr == NULL) {
  414.     setErrorCode(anOp);
  415.     return -1;
  416.   }
  417.   return 0;
  418. }
  420. void
  421. NdbBlob::getHeadFromRecAttr()
  422. {
  423.   assert(theHeadInlineRecAttr != NULL);
  424.   theNullFlag = theHeadInlineRecAttr->isNULL();
  425.   assert(theNullFlag != -1);
  426.   theLength = ! theNullFlag ? theHead->length : 0;
  427.   DBG("getHeadFromRecAttr [out]");
  428. }
  430. int
  431. NdbBlob::setHeadInlineValue(NdbOperation* anOp)
  432. {
  433.   DBG("setHeadInlineValue");
  434.   theHead->length = theLength;
  435.   if (theLength < theInlineSize)
  436.     memset(theInlineData + theLength, 0, theInlineSize - theLength);
  437.   assert(theNullFlag != -1);
  438.   const char* aValue = theNullFlag ? 0 : theHeadInlineBuf.data;
  439.   if (anOp->setValue(theColumn, aValue, theHeadInlineBuf.size) == -1) {
  440.     setErrorCode(anOp);
  441.     return -1;
  442.   }
  443.   theHeadInlineUpdateFlag = false;
  444.   return 0;
  445. }
  447. // getValue/setValue
  449. int
  450. NdbBlob::getValue(void* data, Uint32 bytes)
  451. {
  452.   DBG("getValue data=" << hex << data << " bytes=" << dec << bytes);
  453.   if (theGetFlag || theState != Prepared) {
  454.     setErrorCode(NdbBlobImpl::ErrState);
  455.     return -1;
  456.   }
  457.   if (! isReadOp() && ! isScanOp()) {
  458.     setErrorCode(NdbBlobImpl::ErrUsage);
  459.     return -1;
  460.   }
  461.   if (data == NULL && bytes != 0) {
  462.     setErrorCode(NdbBlobImpl::ErrUsage);
  463.     return -1;
  464.   }
  465.   theGetFlag = true;
  466.   theGetBuf = static_cast<char*>(data);
  467.   theGetSetBytes = bytes;
  468.   return 0;
  469. }
  471. int
  472. NdbBlob::setValue(const void* data, Uint32 bytes)
  473. {
  474.   DBG("setValue data=" << hex << data << " bytes=" << dec << bytes);
  475.   if (theSetFlag || theState != Prepared) {
  476.     setErrorCode(NdbBlobImpl::ErrState);
  477.     return -1;
  478.   }
  479.   if (! isInsertOp() && ! isUpdateOp() && ! isWriteOp()) {
  480.     setErrorCode(NdbBlobImpl::ErrUsage);
  481.     return -1;
  482.   }
  483.   if (data == NULL && bytes != 0) {
  484.     setErrorCode(NdbBlobImpl::ErrUsage);
  485.     return -1;
  486.   }
  487.   theSetFlag = true;
  488.   theSetBuf = static_cast<const char*>(data);
  489.   theGetSetBytes = bytes;
  490.   if (isInsertOp()) {
  491.     // write inline part now
  492.     if (theSetBuf != NULL) {
  493.       Uint32 n = theGetSetBytes;
  494.       if (n > theInlineSize)
  495.         n = theInlineSize;
  496.       assert(thePos == 0);
  497.       if (writeDataPrivate(theSetBuf, n) == -1)
  498.         return -1;
  499.     } else {
  500.       theNullFlag = true;
  501.       theLength = 0;
  502.     }
  503.     if (setHeadInlineValue(theNdbOp) == -1)
  504.       return -1;
  505.   }
  506.   return 0;
  507. }
  509. // activation hook
  511. int
  512. NdbBlob::setActiveHook(ActiveHook activeHook, void* arg)
  513. {
  514.   DBG("setActiveHook hook=" << hex << (void*)activeHook << " arg=" << hex << arg);
  515.   if (theState != Prepared) {
  516.     setErrorCode(NdbBlobImpl::ErrState);
  517.     return -1;
  518.   }
  519.   theActiveHook = activeHook;
  520.   theActiveHookArg = arg;
  521.   return 0;
  522. }
  524. // misc operations
  526. int
  527. NdbBlob::getNull(bool& isNull)
  528. {
  529.   DBG("getNull");
  530.   if (theState == Prepared && theSetFlag) {
  531.     isNull = (theSetBuf == NULL);
  532.     return 0;
  533.   }
  534.   if (theNullFlag == -1) {
  535.     setErrorCode(NdbBlobImpl::ErrState);
  536.     return -1;
  537.   }
  538.   isNull = theNullFlag;
  539.   return 0;
  540. }
  542. int
  543. NdbBlob::setNull()
  544. {
  545.   DBG("setNull");
  546.   if (theNullFlag == -1) {
  547.     if (theState == Prepared) {
  548.       return setValue(0, 0);
  549.     }
  550.     setErrorCode(NdbBlobImpl::ErrState);
  551.     return -1;
  552.   }
  553.   if (theNullFlag)
  554.     return 0;
  555.   if (deleteParts(0, getPartCount()) == -1)
  556.     return -1;
  557.   theNullFlag = true;
  558.   theLength = 0;
  559.   theHeadInlineUpdateFlag = true;
  560.   return 0;
  561. }
  563. int
  564. NdbBlob::getLength(Uint64& len)
  565. {
  566.   DBG("getLength");
  567.   if (theState == Prepared && theSetFlag) {
  568.     len = theGetSetBytes;
  569.     return 0;
  570.   }
  571.   if (theNullFlag == -1) {
  572.     setErrorCode(NdbBlobImpl::ErrState);
  573.     return -1;
  574.   }
  575.   len = theLength;
  576.   return 0;
  577. }
  579. int
  580. NdbBlob::truncate(Uint64 length)
  581. {
  582.   DBG("truncate [in] length=" << length);
  583.   if (theNullFlag == -1) {
  584.     setErrorCode(NdbBlobImpl::ErrState);
  585.     return -1;
  586.   }
  587.   if (theLength > length) {
  588.     if (length > theInlineSize) {
  589.       Uint32 part1 = getPartNumber(length - 1);
  590.       Uint32 part2 = getPartNumber(theLength - 1);
  591.       assert(part2 >= part1);
  592.       if (part2 > part1 && deleteParts(part1 + 1, part2 - part1) == -1)
  593.         return -1;
  594.     } else {
  595.       if (deleteParts(0, getPartCount()) == -1)
  596.         return -1;
  597.     }
  598.     theLength = length;
  599.     theHeadInlineUpdateFlag = true;
  600.     if (thePos > length)
  601.       thePos = length;
  602.   }
  603.   DBG("truncate [out]");
  604.   return 0;
  605. }
  607. int
  608. NdbBlob::getPos(Uint64& pos)
  609. {
  610.   DBG("getPos");
  611.   if (theNullFlag == -1) {
  612.     setErrorCode(NdbBlobImpl::ErrState);
  613.     return -1;
  614.   }
  615.   pos = thePos;
  616.   return 0;
  617. }
  619. int
  620. NdbBlob::setPos(Uint64 pos)
  621. {
  622.   DBG("setPos pos=" << pos);
  623.   if (theNullFlag == -1) {
  624.     setErrorCode(NdbBlobImpl::ErrState);
  625.     return -1;
  626.   }
  627.   if (pos > theLength) {
  628.     setErrorCode(NdbBlobImpl::ErrSeek);
  629.     return -1;
  630.   }
  631.   thePos = pos;
  632.   return 0;
  633. }
  635. // read/write
  637. int
  638. NdbBlob::readData(void* data, Uint32& bytes)
  639. {
  640.   if (theState != Active) {
  641.     setErrorCode(NdbBlobImpl::ErrState);
  642.     return -1;
  643.   }
  644.   char* buf = static_cast<char*>(data);
  645.   return readDataPrivate(buf, bytes);
  646. }
  648. int
  649. NdbBlob::readDataPrivate(char* buf, Uint32& bytes)
  650. {
  651.   DBG("readData [in] bytes=" << bytes);
  652.   assert(thePos <= theLength);
  653.   Uint64 pos = thePos;
  654.   if (bytes > theLength - pos)
  655.     bytes = theLength - pos;
  656.   Uint32 len = bytes;
  657.   if (len > 0) {
  658.     // inline part
  659.     if (pos < theInlineSize) {
  660.       Uint32 n = theInlineSize - pos;
  661.       if (n > len)
  662.         n = len;
  663.       memcpy(buf, theInlineData + pos, n);
  664.       pos += n;
  665.       buf += n;
  666.       len -= n;
  667.     }
  668.   }
  669.   if (len > 0 && thePartSize == 0) {
  670.     setErrorCode(NdbBlobImpl::ErrSeek);
  671.     return -1;
  672.   }
  673.   if (len > 0) {
  674.     assert(pos >= theInlineSize);
  675.     Uint32 off = (pos - theInlineSize) % thePartSize;
  676.     // partial first block
  677.     if (off != 0) {
  678.       DBG("partial first block pos=" << pos << " len=" << len);
  679.       Uint32 part = (pos - theInlineSize) / thePartSize;
  680.       if (readParts(thePartBuf.data, part, 1) == -1)
  681.         return -1;
  682.       // need result now
  683.       if (executePendingBlobReads() == -1)
  684.         return -1;
  685.       Uint32 n = thePartSize - off;
  686.       if (n > len)
  687.         n = len;
  688.       memcpy(buf, thePartBuf.data + off, n);
  689.       pos += n;
  690.       buf += n;
  691.       len -= n;
  692.     }
  693.   }
  694.   if (len > 0) {
  695.     assert((pos - theInlineSize) % thePartSize == 0);
  696.     // complete blocks in the middle
  697.     if (len >= thePartSize) {
  698.       Uint32 part = (pos - theInlineSize) / thePartSize;
  699.       Uint32 count = len / thePartSize;
  700.       if (readParts(buf, part, count) == -1)
  701.         return -1;
  702.       Uint32 n = thePartSize * count;
  703.       pos += n;
  704.       buf += n;
  705.       len -= n;
  706.     }
  707.   }
  708.   if (len > 0) {
  709.     // partial last block
  710.     DBG("partial last block pos=" << pos << " len=" << len);
  711.     assert((pos - theInlineSize) % thePartSize == 0 && len < thePartSize);
  712.     Uint32 part = (pos - theInlineSize) / thePartSize;
  713.     if (readParts(thePartBuf.data, part, 1) == -1)
  714.       return -1;
  715.     // need result now
  716.     if (executePendingBlobReads() == -1)
  717.       return -1;
  718.     memcpy(buf, thePartBuf.data, len);
  719.     Uint32 n = len;
  720.     pos += n;
  721.     buf += n;
  722.     len -= n;
  723.   }
  724.   assert(len == 0);
  725.   thePos = pos;
  726.   assert(thePos <= theLength);
  727.   DBG("readData [out]");
  728.   return 0;
  729. }
  731. int
  732. NdbBlob::writeData(const void* data, Uint32 bytes)
  733. {
  734.   if (theState != Active) {
  735.     setErrorCode(NdbBlobImpl::ErrState);
  736.     return -1;
  737.   }
  738.   const char* buf = static_cast<const char*>(data);
  739.   return writeDataPrivate(buf, bytes);
  740. }
  742. int
  743. NdbBlob::writeDataPrivate(const char* buf, Uint32 bytes)
  744. {
  745.   DBG("writeData [in] bytes=" << bytes);
  746.   assert(thePos <= theLength);
  747.   Uint64 pos = thePos;
  748.   Uint32 len = bytes;
  749.   // any write makes blob not NULL
  750.   if (theNullFlag) {
  751.     theNullFlag = false;
  752.     theHeadInlineUpdateFlag = true;
  753.   }
  754.   if (len > 0) {
  755.     // inline part
  756.     if (pos < theInlineSize) {
  757.       Uint32 n = theInlineSize - pos;
  758.       if (n > len)
  759.         n = len;
  760.       memcpy(theInlineData + pos, buf, n);
  761.       theHeadInlineUpdateFlag = true;
  762.       pos += n;
  763.       buf += n;
  764.       len -= n;
  765.     }
  766.   }
  767.   if (len > 0 && thePartSize == 0) {
  768.     setErrorCode(NdbBlobImpl::ErrSeek);
  769.     return -1;
  770.   }
  771.   if (len > 0) {
  772.     assert(pos >= theInlineSize);
  773.     Uint32 off = (pos - theInlineSize) % thePartSize;
  774.     // partial first block
  775.     if (off != 0) {
  776.       DBG("partial first block pos=" << pos << " len=" << len);
  777.       // flush writes to guarantee correct read
  778.       if (executePendingBlobWrites() == -1)
  779.         return -1;
  780.       Uint32 part = (pos - theInlineSize) / thePartSize;
  781.       if (readParts(thePartBuf.data, part, 1) == -1)
  782.         return -1;
  783.       // need result now
  784.       if (executePendingBlobReads() == -1)
  785.         return -1;
  786.       Uint32 n = thePartSize - off;
  787.       if (n > len) {
  788.         memset(thePartBuf.data + off + len, theFillChar, n - len);
  789.         n = len;
  790.       }
  791.       memcpy(thePartBuf.data + off, buf, n);
  792.       if (updateParts(thePartBuf.data, part, 1) == -1)
  793.         return -1;
  794.       pos += n;
  795.       buf += n;
  796.       len -= n;
  797.     }
  798.   }
  799.   if (len > 0) {
  800.     assert((pos - theInlineSize) % thePartSize == 0);
  801.     // complete blocks in the middle
  802.     if (len >= thePartSize) {
  803.       Uint32 part = (pos - theInlineSize) / thePartSize;
  804.       Uint32 count = len / thePartSize;
  805.       for (unsigned i = 0; i < count; i++) {
  806.         if (part + i < getPartCount()) {
  807.           if (updateParts(buf, part + i, 1) == -1)
  808.             return -1;
  809.         } else {
  810.           if (insertParts(buf, part + i, 1) == -1)
  811.             return -1;
  812.         }
  813.         Uint32 n = thePartSize;
  814.         pos += n;
  815.         buf += n;
  816.         len -= n;
  817.       }
  818.     }
  819.   }
  820.   if (len > 0) {
  821.     // partial last block
  822.     DBG("partial last block pos=" << pos << " len=" << len);
  823.     assert((pos - theInlineSize) % thePartSize == 0 && len < thePartSize);
  824.     Uint32 part = (pos - theInlineSize) / thePartSize;
  825.     if (theLength > pos + len) {
  826.       // flush writes to guarantee correct read
  827.       if (executePendingBlobWrites() == -1)
  828.         return -1;
  829.       if (readParts(thePartBuf.data, part, 1) == -1)
  830.         return -1;
  831.       // need result now
  832.       if (executePendingBlobReads() == -1)
  833.         return -1;
  834.       memcpy(thePartBuf.data, buf, len);
  835.       if (updateParts(thePartBuf.data, part, 1) == -1)
  836.         return -1;
  837.     } else {
  838.       memcpy(thePartBuf.data, buf, len);
  839.       memset(thePartBuf.data + len, theFillChar, thePartSize - len);
  840.       if (part < getPartCount()) {
  841.         if (updateParts(thePartBuf.data, part, 1) == -1)
  842.           return -1;
  843.       } else {
  844.         if (insertParts(thePartBuf.data, part, 1) == -1)
  845.           return -1;
  846.       }
  847.     }
  848.     Uint32 n = len;
  849.     pos += n;
  850.     buf += n;
  851.     len -= n;
  852.   }
  853.   assert(len == 0);
  854.   if (theLength < pos) {
  855.     theLength = pos;
  856.     theHeadInlineUpdateFlag = true;
  857.   }
  858.   thePos = pos;
  859.   assert(thePos <= theLength);
  860.   DBG("writeData [out]");
  861.   return 0;
  862. }
  864. int
  865. NdbBlob::readParts(char* buf, Uint32 part, Uint32 count)
  866. {
  867.   DBG("readParts [in] part=" << part << " count=" << count);
  868.   Uint32 n = 0;
  869.   while (n < count) {
  870.     NdbOperation* tOp = theNdbCon->getNdbOperation(theBlobTable);
  871.     if (tOp == NULL ||
  872.         tOp->committedRead() == -1 ||
  873.         setPartKeyValue(tOp, part + n) == -1 ||
  874.         tOp->getValue((Uint32)3, buf) == NULL) {
  875.       setErrorCode(tOp);
  876.       return -1;
  877.     }
  878.     tOp->m_abortOption = AbortOnError;
  879.     buf += thePartSize;
  880.     n++;
  881.     thePendingBlobOps |= (1 << NdbOperation::ReadRequest);
  882.     theNdbCon->thePendingBlobOps |= (1 << NdbOperation::ReadRequest);
  883.   }
  884.   return 0;
  885. }
  887. int
  888. NdbBlob::insertParts(const char* buf, Uint32 part, Uint32 count)
  889. {
  890.   DBG("insertParts [in] part=" << part << " count=" << count);
  891.   Uint32 n = 0;
  892.   while (n < count) {
  893.     NdbOperation* tOp = theNdbCon->getNdbOperation(theBlobTable);
  894.     if (tOp == NULL ||
  895.         tOp->insertTuple() == -1 ||
  896.         setPartKeyValue(tOp, part + n) == -1 ||
  897.         tOp->setValue((Uint32)3, buf) == -1) {
  898.       setErrorCode(tOp);
  899.       return -1;
  900.     }
  901.     tOp->m_abortOption = AbortOnError;
  902.     buf += thePartSize;
  903.     n++;
  904.     thePendingBlobOps |= (1 << NdbOperation::InsertRequest);
  905.     theNdbCon->thePendingBlobOps |= (1 << NdbOperation::InsertRequest);
  906.   }
  907.   return 0;
  908. }
  910. int
  911. NdbBlob::updateParts(const char* buf, Uint32 part, Uint32 count)
  912. {
  913.   DBG("updateParts [in] part=" << part << " count=" << count);
  914.   Uint32 n = 0;
  915.   while (n < count) {
  916.     NdbOperation* tOp = theNdbCon->getNdbOperation(theBlobTable);
  917.     if (tOp == NULL ||
  918.         tOp->updateTuple() == -1 ||
  919.         setPartKeyValue(tOp, part + n) == -1 ||
  920.         tOp->setValue((Uint32)3, buf) == -1) {
  921.       setErrorCode(tOp);
  922.       return -1;
  923.     }
  924.     tOp->m_abortOption = AbortOnError;
  925.     buf += thePartSize;
  926.     n++;
  927.     thePendingBlobOps |= (1 << NdbOperation::UpdateRequest);
  928.     theNdbCon->thePendingBlobOps |= (1 << NdbOperation::UpdateRequest);
  929.   }
  930.   return 0;
  931. }
  933. int
  934. NdbBlob::deleteParts(Uint32 part, Uint32 count)
  935. {
  936.   DBG("deleteParts [in] part=" << part << " count=" << count);
  937.   Uint32 n = 0;
  938.   while (n < count) {
  939.     NdbOperation* tOp = theNdbCon->getNdbOperation(theBlobTable);
  940.     if (tOp == NULL ||
  941.         tOp->deleteTuple() == -1 ||
  942.         setPartKeyValue(tOp, part + n) == -1) {
  943.       setErrorCode(tOp);
  944.       return -1;
  945.     }
  946.     tOp->m_abortOption = AbortOnError;
  947.     n++;
  948.     thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
  949.     theNdbCon->thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
  950.   }
  951.   return 0;
  952. }
  954. /*
  955.  * Number of blob parts not known.  Used to check for race condition
  956.  * when writeTuple is used for insert.  Deletes all parts found.
  957.  */
  958. int
  959. NdbBlob::deletePartsUnknown(Uint32 part)
  960. {
  961.   DBG("deletePartsUnknown [in] part=" << part << " count=all");
  962.   static const unsigned maxbat = 256;
  963.   static const unsigned minbat = 1;
  964.   unsigned bat = minbat;
  965.   NdbOperation* tOpList[maxbat];
  966.   Uint32 count = 0;
  967.   while (true) {
  968.     Uint32 n;
  969.     n = 0;
  970.     while (n < bat) {
  971.       NdbOperation*& tOp = tOpList[n];  // ref
  972.       tOp = theNdbCon->getNdbOperation(theBlobTable);
  973.       if (tOp == NULL ||
  974.           tOp->deleteTuple() == -1 ||
  975.           setPartKeyValue(tOp, part + count + n) == -1) {
  976.         setErrorCode(tOp);
  977.         return -1;
  978.       }
  979.       tOp->m_abortOption = AO_IgnoreError;
  980.       n++;
  981.     }
  982.     DBG("deletePartsUnknown: executeNoBlobs [in] bat=" << bat);
  983.     if (theNdbCon->executeNoBlobs(NoCommit) == -1)
  984.       return -1;
  985.     DBG("deletePartsUnknown: executeNoBlobs [out]");
  986.     n = 0;
  987.     while (n < bat) {
  988.       NdbOperation* tOp = tOpList[n];
  989.       if (tOp->theError.code != 0) {
  990.         if (tOp->theError.code != 626) {
  991.           setErrorCode(tOp);
  992.           return -1;
  993.         }
  994.         // first non-existent part
  995.         DBG("deletePartsUnknown [out] count=" << count);
  996.         return 0;
  997.       }
  998.       n++;
  999.       count++;
  1000.     }
  1001.     bat *= 4;
  1002.     if (bat > maxbat)
  1003.       bat = maxbat;
  1004.   }
  1005. }
  1007. // pending ops
  1009. int
  1010. NdbBlob::executePendingBlobReads()
  1011. {
  1012.   Uint8 flags = (1 << NdbOperation::ReadRequest);
  1013.   if (thePendingBlobOps & flags) {
  1014.     DBG("executePendingBlobReads: executeNoBlobs [in]");
  1015.     if (theNdbCon->executeNoBlobs(NoCommit) == -1)
  1016.       return -1;
  1017.     DBG("executePendingBlobReads: executeNoBlobs [out]");
  1018.     thePendingBlobOps = 0;
  1019.     theNdbCon->thePendingBlobOps = 0;
  1020.   }
  1021.   return 0;
  1022. }
  1024. int
  1025. NdbBlob::executePendingBlobWrites()
  1026. {
  1027.   Uint8 flags = 0xFF & ~(1 << NdbOperation::ReadRequest);
  1028.   if (thePendingBlobOps & flags) {
  1029.     DBG("executePendingBlobWrites: executeNoBlobs [in]");
  1030.     if (theNdbCon->executeNoBlobs(NoCommit) == -1)
  1031.       return -1;
  1032.     DBG("executePendingBlobWrites: executeNoBlobs [out]");
  1033.     thePendingBlobOps = 0;
  1034.     theNdbCon->thePendingBlobOps = 0;
  1035.   }
  1036.   return 0;
  1037. }
  1039. // callbacks
  1041. int
  1042. NdbBlob::invokeActiveHook()
  1043. {
  1044.   DBG("invokeActiveHook [in]");
  1045.   assert(theState == Active && theActiveHook != NULL);
  1046.   int ret = (*theActiveHook)(this, theActiveHookArg);
  1047.   DBG("invokeActiveHook [out] ret=" << ret);
  1048.   if (ret != 0) {
  1049.     // no error is set on blob level
  1050.     return -1;
  1051.   }
  1052.   return 0;
  1053. }
  1055. // blob handle maintenance
  1057. /*
  1058.  * Prepare blob handle linked to an operation.  Checks blob table.
  1059.  * Allocates buffers.  For key operation fetches key data from signal
  1060.  * data.  For read operation adds read of head+inline.
  1061.  */
  1062. int
  1063. NdbBlob::atPrepare(NdbConnection* aCon, NdbOperation* anOp, const NdbColumnImpl* aColumn)
  1064. {
  1065.   assert(theState == Idle);
  1066.   // ndb api stuff
  1067.   theNdb = anOp->theNdb;
  1068.   theNdbCon = aCon;     // for scan, this is the real transaction (m_transConnection)
  1069.   theNdbOp = anOp;
  1070.   theTable = anOp->m_currentTable;
  1071.   theAccessTable = anOp->m_accessTable;
  1072.   theColumn = aColumn;
  1073.   DBG("atPrepare [in]");
  1074.   NdbDictionary::Column::Type partType = NdbDictionary::Column::Undefined;
  1075.   switch (theColumn->getType()) {
  1076.   case NdbDictionary::Column::Blob:
  1077.     partType = NdbDictionary::Column::Binary;
  1078.     theFillChar = 0x0;
  1079.     break;
  1080.   case NdbDictionary::Column::Text:
  1081.     partType = NdbDictionary::Column::Char;
  1082.     theFillChar = 0x20;
  1083.     break;
  1084.   default:
  1085.     setErrorCode(NdbBlobImpl::ErrUsage);
  1086.     return -1;
  1087.   }
  1088.   // sizes
  1089.   theInlineSize = theColumn->getInlineSize();
  1090.   thePartSize = theColumn->getPartSize();
  1091.   theStripeSize = theColumn->getStripeSize();
  1092.   // sanity check
  1093.   assert((NDB_BLOB_HEAD_SIZE << 2) == sizeof(Head));
  1094.   assert(theColumn->m_attrSize * theColumn->m_arraySize == sizeof(Head) + theInlineSize);
  1095.   if (thePartSize > 0) {
  1096.     const NdbDictionary::Table* bt = NULL;
  1097.     const NdbDictionary::Column* bc = NULL;
  1098.     if (theStripeSize == 0 ||
  1099.         (bt = theColumn->getBlobTable()) == NULL ||
  1100.         (bc = bt->getColumn("DATA")) == NULL ||
  1101.         bc->getType() != partType ||
  1102.         bc->getLength() != (int)thePartSize) {
  1103.       setErrorCode(NdbBlobImpl::ErrTable);
  1104.       return -1;
  1105.     }
  1106.     theBlobTable = &NdbTableImpl::getImpl(*bt);
  1107.   }
  1108.   // buffers
  1109.   theKeyBuf.alloc(theTable->m_sizeOfKeysInWords << 2);
  1110.   theAccessKeyBuf.alloc(theAccessTable->m_sizeOfKeysInWords << 2);
  1111.   theHeadInlineBuf.alloc(sizeof(Head) + theInlineSize);
  1112.   theHeadInlineCopyBuf.alloc(sizeof(Head) + theInlineSize);
  1113.   thePartBuf.alloc(thePartSize);
  1114.   theHead = (Head*)theHeadInlineBuf.data;
  1115.   theInlineData = theHeadInlineBuf.data + sizeof(Head);
  1116.   // handle different operation types
  1117.   bool supportedOp = false;
  1118.   if (isKeyOp()) {
  1119.     if (isTableOp()) {
  1120.       // get table key
  1121.       Uint32* data = (Uint32*)theKeyBuf.data;
  1122.       unsigned size = theTable->m_sizeOfKeysInWords;
  1123.       if (theNdbOp->getKeyFromTCREQ(data, size) == -1) {
  1124.         setErrorCode(NdbBlobImpl::ErrUsage);
  1125.         return -1;
  1126.       }
  1127.     }
  1128.     if (isIndexOp()) {
  1129.       // get index key
  1130.       Uint32* data = (Uint32*)theAccessKeyBuf.data;
  1131.       unsigned size = theAccessTable->m_sizeOfKeysInWords;
  1132.       if (theNdbOp->getKeyFromTCREQ(data, size) == -1) {
  1133.         setErrorCode(NdbBlobImpl::ErrUsage);
  1134.         return -1;
  1135.       }
  1136.     }
  1137.     if (isReadOp()) {
  1138.       // add read of head+inline in this op
  1139.       if (getHeadInlineValue(theNdbOp) == -1)
  1140.         return -1;
  1141.     }
  1142.     if (isInsertOp()) {
  1143.       // becomes NULL unless set before execute
  1144.       theNullFlag = true;
  1145.       theLength = 0;
  1146.     }
  1147.     if (isWriteOp()) {
  1148.       // becomes NULL unless set before execute
  1149.       theNullFlag = true;
  1150.       theLength = 0;
  1151.       theHeadInlineUpdateFlag = true;
  1152.     }
  1153.     supportedOp = true;
  1154.   }
  1155.   if (isScanOp()) {
  1156.     // add read of head+inline in this op
  1157.     if (getHeadInlineValue(theNdbOp) == -1)
  1158.       return -1;
  1159.     supportedOp = true;
  1160.   }
  1161.   if (! supportedOp) {
  1162.     setErrorCode(NdbBlobImpl::ErrUsage);
  1163.     return -1;
  1164.   }
  1165.   setState(Prepared);
  1166.   DBG("atPrepare [out]");
  1167.   return 0;
  1168. }
  1170. /*
  1171.  * Before execute of prepared operation.  May add new operations before
  1172.  * this one.  May ask that this operation and all before it (a "batch")
  1173.  * is executed immediately in no-commit mode.  In this case remaining
  1174.  * prepared operations are saved in a separate list.  They are added
  1175.  * back after postExecute.
  1176.  */
  1177. int
  1178. NdbBlob::preExecute(ExecType anExecType, bool& batch)
  1179. {
  1180.   DBG("preExecute [in]");
  1181.   if (theState == Invalid)
  1182.     return -1;
  1183.   assert(theState == Prepared);
  1184.   // handle different operation types
  1185.   assert(isKeyOp());
  1186.   if (isReadOp()) {
  1187.     if (theGetFlag && theGetSetBytes > theInlineSize) {
  1188.       // need blob head before proceeding
  1189.       batch = true;
  1190.     }
  1191.   }
  1192.   if (isInsertOp()) {
  1193.     if (theSetFlag && theGetSetBytes > theInlineSize) {
  1194.       // add ops to write rest of a setValue
  1195.       assert(theSetBuf != NULL);
  1196.       const char* buf = theSetBuf + theInlineSize;
  1197.       Uint32 bytes = theGetSetBytes - theInlineSize;
  1198.       assert(thePos == theInlineSize);
  1199.       if (writeDataPrivate(buf, bytes) == -1)
  1200.         return -1;
  1201.       if (theHeadInlineUpdateFlag) {
  1202.           // add an operation to update head+inline
  1203.           NdbOperation* tOp = theNdbCon->getNdbOperation(theTable);
  1204.           if (tOp == NULL ||
  1205.               tOp->updateTuple() == -1 ||
  1206.               setTableKeyValue(tOp) == -1 ||
  1207.               setHeadInlineValue(tOp) == -1) {
  1208.             setErrorCode(NdbBlobImpl::ErrAbort);
  1209.             return -1;
  1210.           }
  1211.           DBG("add op to update head+inline");
  1212.       }
  1213.     }
  1214.   }
  1215.   if (isTableOp()) {
  1216.     if (isUpdateOp() || isWriteOp() || isDeleteOp()) {
  1217.       // add operation before this one to read head+inline
  1218.       NdbOperation* tOp = theNdbCon->getNdbOperation(theTable, theNdbOp);
  1219.       if (tOp == NULL ||
  1220.           tOp->readTuple() == -1 ||
  1221.           setTableKeyValue(tOp) == -1 ||
  1222.           getHeadInlineValue(tOp) == -1) {
  1223.         setErrorCode(tOp);
  1224.         return -1;
  1225.       }
  1226.       if (isWriteOp()) {
  1227.         tOp->m_abortOption = AO_IgnoreError;
  1228.       }
  1229.       theHeadInlineReadOp = tOp;
  1230.       // execute immediately
  1231.       batch = true;
  1232.       DBG("add op before to read head+inline");
  1233.     }
  1234.   }
  1235.   if (isIndexOp()) {
  1236.     // add op before this one to read table key
  1237.     NdbBlob* tFirstBlob = theNdbOp->theBlobList;
  1238.     if (this == tFirstBlob) {
  1239.       // first blob does it for all
  1240.       if (g_ndb_blob_ok_to_read_index_table) {
  1241.         Uint32 pkAttrId = theAccessTable->getNoOfColumns() - 1;
  1242.         NdbOperation* tOp = theNdbCon->getNdbOperation(theAccessTable, theNdbOp);
  1243.         if (tOp == NULL ||
  1244.             tOp->readTuple() == -1 ||
  1245.             setAccessKeyValue(tOp) == -1 ||
  1246.             tOp->getValue(pkAttrId, theKeyBuf.data) == NULL) {
  1247.           setErrorCode(tOp);
  1248.           return -1;
  1249.         }
  1250.       } else {
  1251.         NdbIndexOperation* tOp = theNdbCon->getNdbIndexOperation(theAccessTable->m_index, theTable, theNdbOp);
  1252.         if (tOp == NULL ||
  1253.             tOp->readTuple() == -1 ||
  1254.             setAccessKeyValue(tOp) == -1 ||
  1255.             getTableKeyValue(tOp) == -1) {
  1256.           setErrorCode(tOp);
  1257.           return -1;
  1258.         }
  1259.       }
  1260.     }
  1261.     DBG("added op before to read table key");
  1262.     if (isUpdateOp() || isDeleteOp()) {
  1263.       // add op before this one to read head+inline via index
  1264.       NdbIndexOperation* tOp = theNdbCon->getNdbIndexOperation(theAccessTable->m_index, theTable, theNdbOp);
  1265.       if (tOp == NULL ||
  1266.           tOp->readTuple() == -1 ||
  1267.           setAccessKeyValue(tOp) == -1 ||
  1268.           getHeadInlineValue(tOp) == -1) {
  1269.         setErrorCode(tOp);
  1270.         return -1;
  1271.       }
  1272.       if (isWriteOp()) {
  1273.         tOp->m_abortOption = AO_IgnoreError;
  1274.       }
  1275.       theHeadInlineReadOp = tOp;
  1276.       // execute immediately
  1277.       batch = true;
  1278.       DBG("added index op before to read head+inline");
  1279.     }
  1280.     if (isWriteOp()) {
  1281.       // XXX until IgnoreError fixed for index op
  1282.       batch = true;
  1283.     }
  1284.   }
  1285.   if (isWriteOp()) {
  1286.     if (theSetFlag) {
  1287.       // write head+inline now
  1288.       theNullFlag = true;
  1289.       theLength = 0;
  1290.       if (theSetBuf != NULL) {
  1291.         Uint32 n = theGetSetBytes;
  1292.         if (n > theInlineSize)
  1293.           n = theInlineSize;
  1294.         assert(thePos == 0);
  1295.         if (writeDataPrivate(theSetBuf, n) == -1)
  1296.           return -1;
  1297.       }
  1298.       if (setHeadInlineValue(theNdbOp) == -1)
  1299.         return -1;
  1300.       // the read op before us may overwrite
  1301.       theHeadInlineCopyBuf.copyfrom(theHeadInlineBuf);
  1302.     }
  1303.   }
  1304.   if (theActiveHook != NULL) {
  1305.     // need blob head for callback
  1306.     batch = true;
  1307.   }
  1308.   DBG("preExecute [out] batch=" << batch);
  1309.   return 0;
  1310. }
  1312. /*
  1313.  * After execute, for any operation.  If already Active, this routine
  1314.  * has been done previously.  Operations which requested a no-commit
  1315.  * batch can add new operations after this one.  They are added before
  1316.  * any remaining prepared operations.
  1317.  */
  1318. int
  1319. NdbBlob::postExecute(ExecType anExecType)
  1320. {
  1321.   DBG("postExecute [in] type=" << anExecType);
  1322.   if (theState == Invalid)
  1323.     return -1;
  1324.   if (theState == Active) {
  1325.     setState(anExecType == NoCommit ? Active : Closed);
  1326.     DBG("postExecute [skip]");
  1327.     return 0;
  1328.   }
  1329.   assert(theState == Prepared);
  1330.   setState(anExecType == NoCommit ? Active : Closed);
  1331.   assert(isKeyOp());
  1332.   if (isIndexOp()) {
  1333.     NdbBlob* tFirstBlob = theNdbOp->theBlobList;
  1334.     if (this != tFirstBlob) {
  1335.       // copy key from first blob
  1336.       assert(theKeyBuf.size == tFirstBlob->theKeyBuf.size);
  1337.       memcpy(theKeyBuf.data, tFirstBlob->theKeyBuf.data, tFirstBlob->theKeyBuf.size);
  1338.     }
  1339.   }
  1340.   if (isReadOp()) {
  1341.     getHeadFromRecAttr();
  1342.     if (setPos(0) == -1)
  1343.       return -1;
  1344.     if (theGetFlag) {
  1345.       assert(theGetSetBytes == 0 || theGetBuf != 0);
  1346.       assert(theGetSetBytes <= theInlineSize || anExecType == NoCommit);
  1347.       Uint32 bytes = theGetSetBytes;
  1348.       if (readDataPrivate(theGetBuf, bytes) == -1)
  1349.         return -1;
  1350.     }
  1351.   }
  1352.   if (isUpdateOp()) {
  1353.     assert(anExecType == NoCommit);
  1354.     getHeadFromRecAttr();
  1355.     if (theSetFlag) {
  1356.       // setValue overwrites everything
  1357.       if (theSetBuf != NULL) {
  1358.         if (truncate(0) == -1)
  1359.           return -1;
  1360.         assert(thePos == 0);
  1361.         if (writeDataPrivate(theSetBuf, theGetSetBytes) == -1)
  1362.           return -1;
  1363.       } else {
  1364.         if (setNull() == -1)
  1365.           return -1;
  1366.       }
  1367.     }
  1368.   }
  1369.   if (isWriteOp() && isTableOp()) {
  1370.     assert(anExecType == NoCommit);
  1371.     if (theHeadInlineReadOp->theError.code == 0) {
  1372.       int tNullFlag = theNullFlag;
  1373.       Uint64 tLength = theLength;
  1374.       Uint64 tPos = thePos;
  1375.       getHeadFromRecAttr();
  1376.       DBG("tuple found");
  1377.       if (truncate(0) == -1)
  1378.         return -1;
  1379.       // restore previous head+inline
  1380.       theHeadInlineBuf.copyfrom(theHeadInlineCopyBuf);
  1381.       theNullFlag = tNullFlag;
  1382.       theLength = tLength;
  1383.       thePos = tPos;
  1384.     } else {
  1385.       if (theHeadInlineReadOp->theError.code != 626) {
  1386.         setErrorCode(theHeadInlineReadOp);
  1387.         return -1;
  1388.       }
  1389.       DBG("tuple not found");
  1390.       /*
  1391.        * Read found no tuple but it is possible that a tuple was
  1392.        * created after the read by another transaction.  Delete all
  1393.        * blob parts which may exist.
  1394.        */
  1395.       if (deletePartsUnknown(0) == -1)
  1396.         return -1;
  1397.     }
  1398.     if (theSetFlag && theGetSetBytes > theInlineSize) {
  1399.       assert(theSetBuf != NULL);
  1400.       const char* buf = theSetBuf + theInlineSize;
  1401.       Uint32 bytes = theGetSetBytes - theInlineSize;
  1402.       assert(thePos == theInlineSize);
  1403.       if (writeDataPrivate(buf, bytes) == -1)
  1404.           return -1;
  1405.     }
  1406.   }
  1407.   if (isWriteOp() && isIndexOp()) {
  1408.     // XXX until IgnoreError fixed for index op
  1409.     if (deletePartsUnknown(0) == -1)
  1410.       return -1;
  1411.     if (theSetFlag && theGetSetBytes > theInlineSize) {
  1412.       assert(theSetBuf != NULL);
  1413.       const char* buf = theSetBuf + theInlineSize;
  1414.       Uint32 bytes = theGetSetBytes - theInlineSize;
  1415.       assert(thePos == theInlineSize);
  1416.       if (writeDataPrivate(buf, bytes) == -1)
  1417.           return -1;
  1418.     }
  1419.   }
  1420.   if (isDeleteOp()) {
  1421.     assert(anExecType == NoCommit);
  1422.     getHeadFromRecAttr();
  1423.     if (deleteParts(0, getPartCount()) == -1)
  1424.       return -1;
  1425.   }
  1426.   setState(anExecType == NoCommit ? Active : Closed);
  1427.   // activation callback
  1428.   if (theActiveHook != NULL) {
  1429.     if (invokeActiveHook() == -1)
  1430.       return -1;
  1431.   }
  1432.   if (anExecType == NoCommit && theHeadInlineUpdateFlag) {
  1433.     NdbOperation* tOp = theNdbCon->getNdbOperation(theTable);
  1434.     if (tOp == NULL ||
  1435.        tOp->updateTuple() == -1 ||
  1436.        setTableKeyValue(tOp) == -1 ||
  1437.        setHeadInlineValue(tOp) == -1) {
  1438.       setErrorCode(NdbBlobImpl::ErrAbort);
  1439.       return -1;
  1440.     }
  1441.     tOp->m_abortOption = AbortOnError;
  1442.     DBG("added op to update head+inline");
  1443.   }
  1444.   DBG("postExecute [out]");
  1445.   return 0;
  1446. }
  1448. /*
  1449.  * Before commit of completed operation.  For write add operation to
  1450.  * update head+inline.
  1451.  */
  1452. int
  1453. NdbBlob::preCommit()
  1454. {
  1455.   DBG("preCommit [in]");
  1456.   if (theState == Invalid)
  1457.     return -1;
  1458.   assert(theState == Active);
  1459.   assert(isKeyOp());
  1460.   if (isInsertOp() || isUpdateOp() || isWriteOp()) {
  1461.     if (theHeadInlineUpdateFlag) {
  1462.         // add an operation to update head+inline
  1463.         NdbOperation* tOp = theNdbCon->getNdbOperation(theTable);
  1464.         if (tOp == NULL ||
  1465.             tOp->updateTuple() == -1 ||
  1466.             setTableKeyValue(tOp) == -1 ||
  1467.             setHeadInlineValue(tOp) == -1) {
  1468.           setErrorCode(NdbBlobImpl::ErrAbort);
  1469.           return -1;
  1470.         }
  1471.         tOp->m_abortOption = AbortOnError;
  1472.         DBG("added op to update head+inline");
  1473.     }
  1474.   }
  1475.   DBG("preCommit [out]");
  1476.   return 0;
  1477. }
  1479. /*
  1480.  * After next scan result.  Handle like read op above.
  1481.  */
  1482. int
  1483. NdbBlob::atNextResult()
  1484. {
  1485.   DBG("atNextResult [in]");
  1486.   if (theState == Invalid)
  1487.     return -1;
  1488.   assert(isScanOp());
  1489.   // get primary key
  1490.   { Uint32* data = (Uint32*)theKeyBuf.data;
  1491.     unsigned size = theTable->m_sizeOfKeysInWords;
  1492.     if (((NdbScanOperation*)theNdbOp)->getKeyFromKEYINFO20(data, size) == -1) {
  1493.       setErrorCode(NdbBlobImpl::ErrUsage);
  1494.       return -1;
  1495.     }
  1496.   }
  1497.   getHeadFromRecAttr();
  1498.   if (setPos(0) == -1)
  1499.     return -1;
  1500.   if (theGetFlag) {
  1501.     assert(theGetSetBytes == 0 || theGetBuf != 0);
  1502.     Uint32 bytes = theGetSetBytes;
  1503.     if (readDataPrivate(theGetBuf, bytes) == -1)
  1504.       return -1;
  1505.   }
  1506.   setState(Active);
  1507.   // activation callback
  1508.   if (theActiveHook != NULL) {
  1509.     if (invokeActiveHook() == -1)
  1510.       return -1;
  1511.   }
  1512.   DBG("atNextResult [out]");
  1513.   return 0;
  1514. }
  1516. // misc
  1518. const NdbDictionary::Column*
  1519. NdbBlob::getColumn()
  1520. {
  1521.   return theColumn;
  1522. }
  1524. // errors
  1526. void
  1527. NdbBlob::setErrorCode(int anErrorCode, bool invalidFlag)
  1528. {
  1529.   DBG("setErrorCode code=" << anErrorCode);
  1530.   theError.code = anErrorCode;
  1531.   // conditionally copy error to operation level
  1532.   if (theNdbOp != NULL && theNdbOp->theError.code == 0)
  1533.     theNdbOp->setErrorCode(theError.code);
  1534.   if (invalidFlag)
  1535.     setState(Invalid);
  1536. }
  1538. void
  1539. NdbBlob::setErrorCode(NdbOperation* anOp, bool invalidFlag)
  1540. {
  1541.   int code = 0;
  1542.   if (anOp != NULL && (code = anOp->theError.code) != 0)
  1543.     ;
  1544.   else if ((code = theNdbCon->theError.code) != 0)
  1545.     ;
  1546.   else if ((code = theNdb->theError.code) != 0)
  1547.     ;
  1548.   else
  1549.     code = NdbBlobImpl::ErrUnknown;
  1550.   setErrorCode(code, invalidFlag);
  1551. }
  1553. void
  1554. NdbBlob::setErrorCode(NdbConnection* aCon, bool invalidFlag)
  1555. {
  1556.   int code = 0;
  1557.   if (theNdbCon != NULL && (code = theNdbCon->theError.code) != 0)
  1558.     ;
  1559.   else if ((code = theNdb->theError.code) != 0)
  1560.     ;
  1561.   else
  1562.     code = NdbBlobImpl::ErrUnknown;
  1563.   setErrorCode(code, invalidFlag);
  1564. }
  1566. // info about all blobs in this operation
  1568. NdbBlob*
  1569. NdbBlob::blobsFirstBlob()
  1570. {
  1571.   return theNdbOp->theBlobList;
  1572. }
  1574. NdbBlob*
  1575. NdbBlob::blobsNextBlob()
  1576. {
  1577.   return theNext;
  1578. }
  1580. // debug
  1582. #ifdef VM_TRACE
  1583. inline int
  1584. NdbBlob::getOperationType() const
  1585. {
  1586.   return theNdbOp != NULL ? theNdbOp->theOperationType : -1;
  1587. }
  1589. NdbOut&
  1590. operator<<(NdbOut& out, const NdbBlob& blob)
  1591. {
  1592.   ndbout << dec << "o=" << blob.getOperationType();
  1593.   ndbout << dec << " s=" << (Uint32) blob.theState;
  1594.   ndbout << dec << " n=" << blob.theNullFlag;;
  1595.   ndbout << dec << " l=" << blob.theLength;
  1596.   ndbout << dec << " p=" << blob.thePos;
  1597.   ndbout << dec << " u=" << (Uint32)blob.theHeadInlineUpdateFlag;
  1598.   ndbout << dec << " g=" << (Uint32)blob.theGetSetBytes;
  1599.   return out;
  1600. }
  1601. #endif