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

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

MySQL数据库

开发平台：

Visual C++

dba_binding.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. #include "dba_internal.hpp"
  20. static bool matchType(NdbDictionary::Column::Type, DBA_DataTypes_t);
  21. static bool matchSize(NdbDictionary::Column::Type, unsigned, Size_t);
  22. static int  computeChecksum(const DBA_Binding_t * bindings);
  24. struct DBA__Array {
  25.   int count;
  26.   int data[1];
  28.   bool exists(int value) const {
  29.     for(int i = 0; i<count; i++)
  30.       if(data[i] == value)
  31. return true;
  32.     return false;
  33.   }
  35.   void insert(int value){
  36.     data[count] = value;
  37.     count++;
  38.   }
  39. };
  41. /**
  42.  * createBindings
  43.  */
  44. static 
  45. DBA_Binding_t *
  46. createBinding(const char* TableName, 
  47.       int NbCol,
  48.       const DBA_ColumnBinding_t ColsBindings[],
  49.       Size_t StructSz,
  50.       const NdbDictionary::Table * theTable, 
  51.       struct DBA__Array * keys,
  52.       struct DBA__Array * columns);
  54. extern "C"
  55. DBA_Binding_t *
  56. DBA_CreateBinding( const char* TableName, 
  57.    int NbCol, 
  58.    const DBA_ColumnBinding_t ColsBindings[], 
  59.    Size_t StructSz ){
  61.   NdbDictionary::Dictionary * dict = DBA__TheNdb->getDictionary();
  62.   if(dict == 0){
  63.     DBA__SetLatestError(DBA_NDB_ERROR, 0, 
  64. "Internal NDB error: No dictionary");
  65.     return 0;
  66.   }
  67.   
  68.   const NdbDictionary::Table * table = dict->getTable(TableName);
  69.   if(table == 0){
  70.     DBA__SetLatestError(DBA_APPLICATION_ERROR, 0, 
  71. "No such table: %s", TableName);
  72.     return 0;
  73.   }
  74.   
  75.   /**
  76.    * Keys/Columns in table
  77.    */
  78.   const int tabColumns = table->getNoOfColumns();
  79.   const int tabKeys    = table->getNoOfPrimaryKeys();
  80.   
  81.   /**
  82.    * Ok, ok... I alloc four bytes extra so what...
  83.    */
  84.   struct DBA__Array * keys    = (struct DBA__Array *)malloc
  85.     (sizeof(struct DBA__Array)+tabKeys*sizeof(int));
  87.   if(keys == 0){
  88.     DBA__SetLatestError(DBA_ERROR, 0,
  89. "malloc(%d) failed", 
  90. sizeof(struct DBA__Array)+tabKeys*sizeof(int));
  91.     return 0;
  92.   }
  93.   
  94.   struct DBA__Array * columns = (struct DBA__Array *)malloc
  95.     (sizeof(struct DBA__Array)+tabColumns*sizeof(int));
  96.   
  97.   if(columns == 0){
  98.     DBA__SetLatestError(DBA_ERROR, 0,
  99. "malloc(%d) failed", 
  100. sizeof(struct DBA__Array)+tabColumns*sizeof(int));
  101.     free(keys);
  102.     return 0;
  103.   }
  104.   
  105.   columns->count = 0;
  106.   keys->count = 0;
  107.   
  108.   DBA_Binding_t * bindings = createBinding(TableName,
  109.    NbCol,
  110.    ColsBindings,
  111.    StructSz,
  112.    table, 
  113.    keys,
  114.    columns);
  115.   
  116.   for(int i = 0; i<tabColumns; i++){
  117.     const NdbDictionary::Column * col = table->getColumn(i);
  118.     if(col->getPrimaryKey()){
  119.       if(!keys->exists(i)){
  120. DBA__SetLatestError(DBA_APPLICATION_ERROR, 0,
  121.     "Key column: %s not specified in binding",
  122.     col->getName());
  124. free(keys); free(columns);
  125. DBA_DestroyBinding(bindings);
  126. return 0;
  127.       }
  128.     }
  129.   }
  130.   
  131.   free(keys); free(columns);
  132.   
  133.   DBA__ValidBinding(bindings);
  135.   return bindings;
  136. }
  138. DBA_Binding_t *
  139. createBinding(const char* TableName, 
  140.       int NbCol,
  141.       const DBA_ColumnBinding_t ColsBindings[],
  142.       Size_t StructSz,
  143.       const NdbDictionary::Table * table, 
  144.       struct DBA__Array * keys,
  145.       struct DBA__Array * columns){
  146.   /**
  147.    * Counters for this part of binding
  148.    */
  149.   int noOfKeys        = 0;
  150.   int noOfColumns     = 0;
  151.   int noOfSubBindings = 0;
  153.   /**
  154.    * Check names and types and sizes
  155.    */
  156.   for(int i = 0; i<NbCol; i++){
  157.     if(ColsBindings[i].Ptr){
  158.       /**
  159.        * Pointer binding
  160.        */
  161.       noOfSubBindings ++;
  163.       DBA_Binding_t * tmp = createBinding(TableName,
  164.   ColsBindings[i].Size,
  165.   ColsBindings[i].SubBinding,
  166.   StructSz,
  167.   table,
  168.   keys,
  169.   columns);
  170.       DBA__ValidBinding(tmp);
  171.       
  172.       if(tmp == 0){
  173. // createBindings have already set latestError
  174. return 0;
  175.       }
  176.       
  177.       DBA_DestroyBinding(tmp);
  178.     } else {
  179.       const NdbDictionary::Column * col = 
  180. table->getColumn(ColsBindings[i].Name);
  181.       const Uint32 attrId = col->getColumnNo();
  183.       if(col == 0){
  184. DBA__SetLatestError(DBA_APPLICATION_ERROR, 0,
  185.     "Unknown column: %s", ColsBindings[i].Name);
  186. return 0;
  187.       }
  188.       const NdbDictionary::Column::Type type = col->getType();
  189.       if(!matchType(type, ColsBindings[i].DataType)){
  190. DBA_DEBUG("Incorrect type for: " << ColsBindings[i].Name);
  191. DBA_DEBUG("type: " << type);
  192. DBA_DEBUG("ColsBindings[i].DataType: " << ColsBindings[i].DataType);
  194. DBA__SetLatestError(DBA_APPLICATION_ERROR, 0,
  195.     "Incorrect type for column: %s", 
  196.     ColsBindings[i].Name);
  198. return 0;
  199.       }
  201.       if(!matchSize(type, col->getLength(), ColsBindings[i].Size)){
  202. DBA_DEBUG("Incorrect size for: " << ColsBindings[i].Name);
  203. DBA_DEBUG("type: " << type);
  204. DBA_DEBUG("length: " << col->getLength());
  205. DBA_DEBUG("ColsBindings[i].Size" << (Uint64)ColsBindings[i].Size);
  207. DBA__SetLatestError(DBA_APPLICATION_ERROR, 0,
  208.     "Incorrect size for column: %s", 
  209.     ColsBindings[i].Name);
  210. return 0;
  211.       }
  212.       
  213.       if(col->getPrimaryKey()){
  214. noOfKeys++;
  215.       } else {
  216. noOfColumns++;
  217.       }
  218.       
  219.       /**
  220.        * Check only in "validate" phase
  221.        */
  222.       if(columns != 0 && keys != 0){
  223. if(columns->exists(attrId) || keys->exists(attrId)){
  224.   DBA_DEBUG("Column bound multiple times: " << ColsBindings[i].Name);
  225.   
  226.   DBA__SetLatestError(DBA_APPLICATION_ERROR, 0,
  227.       "Column bound multiple times: %s",
  228.       ColsBindings[i].Name);
  229.   return 0;
  230. }
  232. if(col->getPrimaryKey()){
  233.   keys->insert(attrId);
  234. } else {
  235.   columns->insert(attrId);
  236. }
  237.       }
  238.     }
  239.   }
  240.   
  241.   /**
  242.    * Validation is all set
  243.    */
  244.   
  245.   /**
  246.    * Allocate memory
  247.    */
  248.   const int szOfStruct = 
  249.     sizeof(DBA_Binding_t)
  250.     + strlen(TableName) + 4
  251.     + (2 * sizeof(int) * noOfKeys)
  252.     + (2 * sizeof(int) * noOfColumns)
  253.     + ((sizeof(struct DBA_Binding *) + sizeof(int)) * noOfSubBindings)
  254.     - 4;
  255.   
  256.   DBA_Binding * ret = (DBA_Binding *)malloc(szOfStruct);
  257.   if(ret == 0){
  258.     DBA__SetLatestError(DBA_ERROR, 0,
  259. "malloc(%d) failed", szOfStruct);
  260.     return 0;
  261.   }
  262.   
  263.   for(int i = 0; i<DBA__MagicLength; i++)
  264.     ret->magic[i] = DBA__TheMagic[i];
  265.   
  266.   ret->noOfKeys          = noOfKeys;
  267.   ret->noOfColumns       = noOfColumns;
  268.   ret->noOfSubBindings   = noOfSubBindings;
  270.   ret->keyIds            = (int *)&(ret->data[0]);
  271.   ret->keyOffsets        = ret->keyIds + noOfKeys;
  273.   ret->columnIds         = ret->keyOffsets + noOfKeys;
  274.   ret->columnOffsets     = ret->columnIds + noOfColumns;
  276.   ret->subBindingOffsets = ret->columnOffsets + noOfColumns;
  277.   ret->subBindings       = (DBA_Binding **)
  278.     (ret->subBindingOffsets + noOfSubBindings);
  279.   
  280.   ret->tableName         = (char *)(ret->subBindings + noOfSubBindings);
  281.   ret->structSz          = StructSz;
  282.   ret->checkSum          = computeChecksum(ret);
  284.   /**
  285.    * Populate arrays
  286.    */
  287.   strcpy(ret->tableName, TableName);
  289.   int k = 0;
  290.   int c = 0;
  291.   int p = 0;
  293.   for(int i = 0; i<NbCol; i++){
  294.     if(ColsBindings[i].Ptr){
  295.       ret->subBindings[p] = createBinding(TableName,
  296.   ColsBindings[i].Size,
  297.   ColsBindings[i].SubBinding,
  298.   StructSz,
  299.   table, 
  300.   0, 
  301.   0);
  302.       
  303.       DBA__ValidBinding(ret->subBindings[p]);
  305.       ret->subBindingOffsets[p] = ColsBindings[i].Offset;
  306.       p++;
  307.     } else {
  308.       const NdbDictionary::Column * col = 
  309. table->getColumn(ColsBindings[i].Name);
  311.       if(col->getPrimaryKey()){
  312. ret->keyIds[k]     = col->getColumnNo();
  313. ret->keyOffsets[k] = ColsBindings[i].Offset;
  314. k++;
  315.       } else {
  316. ret->columnIds[c]     = col->getColumnNo();
  317. ret->columnOffsets[c] = ColsBindings[i].Offset;
  318. c++;
  319.       }
  320.     }  
  321.   }
  322.   
  323.   return ret;
  324. }
  327. extern "C"
  328. DBA_Error_t 
  329. DBA_DestroyBinding( DBA_Binding_t* Binding ){
  331.   for(int i = 0; i<Binding->noOfSubBindings; i++)
  332.     DBA_DestroyBinding(Binding->subBindings[i]);
  333.   
  334.   free(Binding);
  335.   
  336.   return DBA_NO_ERROR;
  337. }
  339. static
  340. bool
  341. matchType(NdbDictionary::Column::Type t1, DBA_DataTypes_t t2){
  342.   for(int i = 0; i<DBA__NoOfMappings; i++)
  343.     if(DBA__DataTypesMappings[i].newtonType == t2 &&
  344.        DBA__DataTypesMappings[i].ndbType    == t1)
  345.       return true;
  346.   return false;
  347. }
  349. static
  350. bool
  351. matchSize(NdbDictionary::Column::Type t, unsigned b, Size_t s) {
  352.   switch(t){
  353.   case NdbDictionary::Column::Int:
  354.   case NdbDictionary::Column::Unsigned:
  355.   case NdbDictionary::Column::Float:
  356.     return (4 * b) == s;
  357.   case NdbDictionary::Column::Bigint:
  358.   case NdbDictionary::Column::Bigunsigned:
  359.   case NdbDictionary::Column::Double:
  360.     return (8 * b) == s;
  361.   case NdbDictionary::Column::Decimal:
  362.   case NdbDictionary::Column::Char:
  363.   case NdbDictionary::Column::Binary:
  364.     return (1 * b) == s;
  365.   case NdbDictionary::Column::Varchar:
  366.   case NdbDictionary::Column::Varbinary:
  367.   case NdbDictionary::Column::Datetime:
  368.   case NdbDictionary::Column::Timespec:
  369.   case NdbDictionary::Column::Blob:
  370.   case NdbDictionary::Column::Tinyint:
  371.   case NdbDictionary::Column::Tinyunsigned:
  372.   case NdbDictionary::Column::Smallint:
  373.   case NdbDictionary::Column::Smallunsigned:
  374.   case NdbDictionary::Column::Mediumint:
  375.   case NdbDictionary::Column::Mediumunsigned:
  376.   case NdbDictionary::Column::Undefined:
  377.     return false;
  378.   }
  379.   return false;
  380. }
  382. bool
  383. DBA__ValidBinding(const DBA_Binding_t * bindings){
  384.   if(bindings == 0){
  385.     DBA_DEBUG("Null pointer passed to validBinding");
  386.     return false;
  387.   }
  388.   
  389.   for(int i = 0; i<DBA__MagicLength; i++)
  390.     if(bindings->magic[i] != DBA__TheMagic[i]){
  391.       DBA_DEBUG("Invalid magic in validBinding");
  392.       return false;
  393.     }
  394.   
  395.   const int cs = computeChecksum(bindings);
  396.   if(cs != bindings->checkSum){
  397.     DBA_DEBUG("Invalid checksum in validBinding");
  398.     DBA_DEBUG("cs = " << cs << " b->cs= " << bindings->checkSum);
  399.     return false;
  400.   }
  402.   return true;
  403. }
  405. bool
  406. DBA__ValidBindings(const DBA_Binding_t * const * pBindings, int n){
  407.   for(int i = 0; i<n; i++)
  408.     if(!DBA__ValidBinding(pBindings[i]))
  409.       return false;
  410.   return true;
  411. }
  413. /**
  414.  * Note: currently only checksum "static" part of struct
  415.  */
  416. static
  417. int
  418. computeChecksum(const DBA_Binding_t * bindings){
  419.   int sum = 0;
  420.   int pos = 0;
  421.   const char * ptr = ((const char *)bindings)+DBA__MagicLength+sizeof(int);
  422.   const int sz = sizeof(DBA_Binding_t) - DBA__MagicLength - sizeof(int) - 4;
  424.   for(int i = 0; i<sz; i++){
  425.     sum += ((int)ptr[i]) << pos;
  426.     pos += 8;
  427.     if(pos == 32)
  428.       pos = 0;
  429.   }
  430.   
  431.   return sum;
  432. }
  434. int
  435. DBA__GetStructSize(const DBA_Binding_t * bind){
  436.   if(!DBA__ValidBinding(bind))
  437.     return 0;
  438.   return bind->structSz;
  439. }