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

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

MySQL数据库

开发平台：

Visual C++

NdbRecAttr.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 */
  18. /************************************************************************************************
  19. Name:          NdbRecAttr.C
  20. Include:
  21. Link:
  22. Author:        UABRONM Mikael Ronstr鰉 UAB/B/SD                         
  23. Date:          971206
  24. Version:       0.1
  25. Description:   Interface between TIS and NDB
  26. Documentation:
  27. Adjust:  971206  UABRONM First version
  28. ************************************************************************************************/
  29. #include <ndb_global.h>
  30. #include <NdbOut.hpp>
  31. #include <NdbRecAttr.hpp>
  32. #include <NdbBlob.hpp>
  33. #include "NdbDictionaryImpl.hpp"
  34. #include <NdbTCP.h>
  36. NdbRecAttr::NdbRecAttr(Ndb*)
  37. {
  38.   init();
  39. }
  41. NdbRecAttr::~NdbRecAttr()
  42. {
  43.   release();
  44. }
  46. int
  47. NdbRecAttr::setup(const class NdbDictionary::Column* col, char* aValue)
  48. {
  49.   return setup(&(col->m_impl), aValue);
  50. }
  51. int
  52. NdbRecAttr::setup(const NdbColumnImpl* anAttrInfo, char* aValue)
  53. {
  54.   Uint32 tAttrSize = anAttrInfo->m_attrSize;
  55.   Uint32 tArraySize = anAttrInfo->m_arraySize;
  56.   Uint32 tAttrByteSize = tAttrSize * tArraySize;
  57.   
  58.   m_column = anAttrInfo;
  60.   theAttrId = anAttrInfo->m_attrId;
  61.   theAttrSize = tAttrSize;
  62.   theArraySize = tArraySize;
  63.   theValue = aValue;
  64.   theNULLind = 0;
  65.   m_nullable = anAttrInfo->m_nullable;
  67.   // check alignment to signal data
  68.   // a future version could check alignment per data type as well
  69.   
  70.   if (aValue != NULL && (UintPtr(aValue)&3) == 0 && (tAttrByteSize&3) == 0) {
  71.     theStorageX = NULL;
  72.     theRef = aValue;
  73.     return 0;
  74.   }
  75.   if (tAttrByteSize <= 32) {
  76.     theStorageX = NULL;
  77.     theStorage[0] = 0;
  78.     theStorage[1] = 0;
  79.     theStorage[2] = 0;
  80.     theStorage[3] = 0;
  81.     theRef = theStorage;
  82.     return 0;
  83.   }
  84.   Uint32 tSize = (tAttrByteSize + 7) >> 3;
  85.   Uint64* tRef = new Uint64[tSize];
  86.   if (tRef != NULL) {
  87.     for (Uint32 i = 0; i < tSize; i++) {
  88.       tRef[i] = 0;
  89.     }
  90.     theStorageX = tRef;
  91.     theRef = tRef;
  92.     return 0;
  93.   }
  94.   return -1;
  95. }
  97. void
  98. NdbRecAttr::copyout()
  99. {
  100.   char* tRef = (char*)theRef;
  101.   char* tValue = theValue;
  102.   if (tRef != tValue && tRef != NULL && tValue != NULL) {
  103.     Uint32 n = theAttrSize * theArraySize;
  104.     while (n-- > 0) {
  105.       *tValue++ = *tRef++;
  106.     }
  107.   }
  108. }
  110. NdbRecAttr *
  111. NdbRecAttr::clone() const {
  112.   NdbRecAttr * ret = new NdbRecAttr(0);
  114.   ret->theAttrId = theAttrId;
  115.   ret->theNULLind = theNULLind;
  116.   ret->theAttrSize = theAttrSize;
  117.   ret->theArraySize = theArraySize;
  118.   ret->m_column = m_column;
  119.   
  120.   Uint32 n = theAttrSize * theArraySize;  
  121.   if(n <= 32){
  122.     ret->theRef = (char*)&ret->theStorage[0];
  123.     ret->theStorageX = 0;
  124.     ret->theValue = 0;
  125.   } else {
  126.     ret->theStorageX = new Uint64[((n + 7) >> 3)];
  127.     ret->theRef = (char*)ret->theStorageX;    
  128.     ret->theValue = 0;
  129.   }
  130.   memcpy(ret->theRef, theRef, n);
  131.   return ret;
  132. }
  134. bool
  135. NdbRecAttr::receive_data(const Uint32 * data, Uint32 sz){
  136.   const Uint32 n = (theAttrSize * theArraySize + 3) >> 2;  
  137.   if(n == sz){
  138.     theNULLind = 0;
  139.     if(!copyoutRequired())
  140.       memcpy(theRef, data, 4 * sz);
  141.     else
  142.       memcpy(theValue, data, theAttrSize * theArraySize);
  143.     return true;
  144.   } else if(sz == 0){
  145.     setNULL();
  146.     return true;
  147.   }
  148.   return false;
  149. }
  151. NdbOut& operator<<(NdbOut& out, const NdbRecAttr &r)
  152. {
  153.   if (r.isNULL())
  154.   {
  155.     out << "[NULL]";
  156.     return out;
  157.   }
  159.   const NdbDictionary::Column* c = r.getColumn();
  160.   uint length = c->getLength();
  161.   if (length > 1)
  162.     out << "[";
  164.   for (Uint32 j = 0; j < length; j++) 
  165.   {
  166.     if (j > 0)
  167.       out << " ";
  169.     switch(r.getType())
  170.       {
  171.       case NdbDictionary::Column::Bigunsigned:
  172. out << r.u_64_value();
  173. break;
  174.       case NdbDictionary::Column::Unsigned:
  175. out << r.u_32_value();
  176. break;
  177.       case NdbDictionary::Column::Smallunsigned:
  178. out << r.u_short_value();
  179. break;
  180.       case NdbDictionary::Column::Tinyunsigned:
  181. out << (unsigned) r.u_char_value();
  182. break;
  183.       case NdbDictionary::Column::Bigint:
  184. out << r.int64_value();
  185. break;
  186.       case NdbDictionary::Column::Int:
  187. out << r.int32_value();
  188. break;
  189.       case NdbDictionary::Column::Smallint:
  190. out << r.short_value();
  191. break;
  192.       case NdbDictionary::Column::Tinyint:
  193. out << (int) r.char_value();
  194. break;
  195.       case NdbDictionary::Column::Char:
  196. out.print("%.*s", r.arraySize(), r.aRef());
  197. j = length;
  198. break;
  199.       case NdbDictionary::Column::Varchar:
  200. {
  201.   short len = ntohs(r.u_short_value());
  202.   out.print("%.*s", len, r.aRef()+2);
  203. }
  204. j = length;
  205.       break;
  206.       case NdbDictionary::Column::Float:
  207. out << r.float_value();
  208. break;
  209.       case NdbDictionary::Column::Double:
  210. out << r.double_value();
  211. break;
  212.       case NdbDictionary::Column::Olddecimal:
  213.         {
  214.           short len = 1 + c->getPrecision() + (c->getScale() > 0);
  215.           out.print("%.*s", len, r.aRef());
  216.         }
  217.         break;
  218.       case NdbDictionary::Column::Olddecimalunsigned:
  219.         {
  220.           short len = 0 + c->getPrecision() + (c->getScale() > 0);
  221.           out.print("%.*s", len, r.aRef());
  222.         }
  223. break;
  224.       // for dates cut-and-paste from field.cc
  225.       case NdbDictionary::Column::Datetime:
  226.         {
  227.           ulonglong tmp=r.u_64_value();
  228.           long part1,part2,part3;
  229.           part1=(long) (tmp/LL(1000000));
  230.           part2=(long) (tmp - (ulonglong) part1*LL(1000000));
  231.           char buf[40];
  232.           char* pos=(char*) buf+19;
  233.           *pos--=0;
  234.           *pos--= (char) ('0'+(char) (part2%10)); part2/=10; 
  235.           *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
  236.           *pos--= ':';
  237.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  238.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  239.           *pos--= ':';
  240.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  241.           *pos--= (char) ('0'+(char) part3);
  242.           *pos--= '/';
  243.           *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  244.           *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  245.           *pos--= '-';
  246.           *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
  247.           *pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
  248.           *pos--= '-';
  249.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  250.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  251.           *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
  252.           *pos=(char) ('0'+(char) part3);
  253.           out << buf;
  254.         }
  255. break;
  256.       case NdbDictionary::Column::Date:
  257.         {
  258.           uint32 tmp=(uint32) uint3korr(r.aRef());
  259.           int part;
  260.           char buf[40];
  261.           char *pos=(char*) buf+10;
  262.           *pos--=0;
  263.           part=(int) (tmp & 31);
  264.           *pos--= (char) ('0'+part%10);
  265.           *pos--= (char) ('0'+part/10);
  266.           *pos--= '-';
  267.           part=(int) (tmp >> 5 & 15);
  268.           *pos--= (char) ('0'+part%10);
  269.           *pos--= (char) ('0'+part/10);
  270.           *pos--= '-';
  271.           part=(int) (tmp >> 9);
  272.           *pos--= (char) ('0'+part%10); part/=10;
  273.           *pos--= (char) ('0'+part%10); part/=10;
  274.           *pos--= (char) ('0'+part%10); part/=10;
  275.           *pos=   (char) ('0'+part);
  276.           out << buf;
  277.         }
  278. break;
  279.       case NdbDictionary::Column::Time:
  280.         {
  281.           long tmp=(long) sint3korr(r.aRef());
  282.           int hour=(uint) (tmp/10000);
  283.           int minute=(uint) (tmp/100 % 100);
  284.           int second=(uint) (tmp % 100);
  285.           char buf[40];
  286.           sprintf(buf, "%02d:%02d:%02d", hour, minute, second);
  287.           out << buf;
  288.         }
  289. break;
  290.       case NdbDictionary::Column::Year:
  291.         {
  292.           uint year = 1900 + r.u_char_value();
  293.           char buf[40];
  294.           sprintf(buf, "%04d", year);
  295.           out << buf;
  296.         }
  297. break;
  298.       case NdbDictionary::Column::Timestamp:
  299.         {
  300.           time_t time = r.u_32_value();
  301.           out << (uint)time;
  302.         }
  303. break;
  304.       case NdbDictionary::Column::Blob:
  305.         {
  306.           const NdbBlob::Head* h = (const NdbBlob::Head*)r.aRef();
  307.           out << h->length << ":";
  308.           const unsigned char* p = (const unsigned char*)(h + 1);
  309.           unsigned n = r.arraySize() - sizeof(*h);
  310.           for (unsigned k = 0; k < n && k < h->length; k++)
  311.             out.print("%02X", (int)p[k]);
  312.           j = length;
  313.         }
  314.         break;
  315.       case NdbDictionary::Column::Text:
  316.         {
  317.           const NdbBlob::Head* h = (const NdbBlob::Head*)r.aRef();
  318.           out << h->length << ":";
  319.           const unsigned char* p = (const unsigned char*)(h + 1);
  320.           unsigned n = r.arraySize() - sizeof(*h);
  321.           for (unsigned k = 0; k < n && k < h->length; k++)
  322.             out.print("%c", (int)p[k]);
  323.           j = length;
  324.         }
  325.         break;
  326.       default: /* no print functions for the rest, just print type */
  327. out << (int) r.getType();
  328. j = length;
  329. if (j > 1)
  330.   out << " " << j << " times";
  331. break;
  332.       }
  333.   }
  335.   if (length > 1)
  336.   {
  337.     out << "]";
  338.   }
  340.   return out;
  341. }
  343. Int64
  344. NdbRecAttr::int64_value() const 
  345. {
  346.   Int64 val;
  347.   memcpy(&val,theRef,8);
  348.   return val;
  349. }
  351. Uint64
  352. NdbRecAttr::u_64_value() const
  353. {
  354.   Uint64 val;
  355.   memcpy(&val,theRef,8);
  356.   return val;
  357. }
  359. float
  360. NdbRecAttr::float_value() const
  361. {
  362.   float val;
  363.   memcpy(&val,theRef,sizeof(val));
  364.   return val;
  365. }
  367. double
  368. NdbRecAttr::double_value() const
  369. {
  370.   double val;
  371.   memcpy(&val,theRef,sizeof(val));
  372.   return val;
  373. }