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

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

MySQL数据库

开发平台：

Visual C++

NdbSqlUtil.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 <NdbSqlUtil.hpp>
  19. int
  20. NdbSqlUtil::char_compare(const char* s1, unsigned n1,
  21.                          const char* s2, unsigned n2, bool padded)
  22. {
  23.   int c1 = 0;
  24.   int c2 = 0;
  25.   unsigned i = 0;
  26.   while (i < n1 || i < n2) {
  27.     c1 = i < n1 ? s1[i] : padded ? 0x20 : 0;
  28.     c2 = i < n2 ? s2[i] : padded ? 0x20 : 0;
  29.     if (c1 != c2)
  30.       break;
  31.     i++;
  32.   }
  33.   return c1 - c2;
  34. }
  36. bool
  37. NdbSqlUtil::char_like(const char* s1, unsigned n1,
  38.                       const char* s2, unsigned n2, bool padded)
  39. {
  40.   int c1 = 0;
  41.   int c2 = 0;
  42.   unsigned i1 = 0;
  43.   unsigned i2 = 0;
  44.   while (i1 < n1 || i2 < n2) {
  45.     c1 = i1 < n1 ? s1[i1] : padded ? 0x20 : 0;
  46.     c2 = i2 < n2 ? s2[i2] : padded ? 0x20 : 0;
  47.     if (c2 == '%') {
  48.       while (i2 + 1 < n2 && s2[i2 + 1] == '%') {
  49.         i2++;
  50.       }
  51.       unsigned m = 0;
  52.       while (m <= n1 - i1) {
  53.         if (char_like(s1 + i1 + m, n1 -i1 - m,
  54.                       s2 + i2 + 1, n2 - i2 - 1, padded))
  55.         return true;
  56.         m++;
  57.       }
  58.       return false;
  59.     }
  60.     if (c2 == '_') {
  61.       if (c1 == 0)
  62.         return false;
  63.     } else {
  64.       if (c1 != c2)
  65.         return false;
  66.     }
  67.     i1++;
  68.     i2++;
  69.   }
  70.   return i1 == n2 && i2 == n2;
  71. }
  73. /**
  74.  * Data types.
  75.  */
  77. const NdbSqlUtil::Type
  78. NdbSqlUtil::m_typeList[] = {
  79.   { // 0
  80.     Type::Undefined,
  81.     NULL
  82.   },
  83.   { // 1
  84.     Type::Tinyint,
  85.     cmpTinyint
  86.   },
  87.   { // 2
  88.     Type::Tinyunsigned,
  89.     cmpTinyunsigned
  90.   },
  91.   { // 3
  92.     Type::Smallint,
  93.     cmpSmallint
  94.   },
  95.   { // 4
  96.     Type::Smallunsigned,
  97.     cmpSmallunsigned
  98.   },
  99.   { // 5
  100.     Type::Mediumint,
  101.     cmpMediumint
  102.   },
  103.   { // 6
  104.     Type::Mediumunsigned,
  105.     cmpMediumunsigned
  106.   },
  107.   { // 7
  108.     Type::Int,
  109.     cmpInt
  110.   },
  111.   { // 8
  112.     Type::Unsigned,
  113.     cmpUnsigned
  114.   },
  115.   { // 9
  116.     Type::Bigint,
  117.     cmpBigint
  118.   },
  119.   { // 10
  120.     Type::Bigunsigned,
  121.     cmpBigunsigned
  122.   },
  123.   { // 11
  124.     Type::Float,
  125.     cmpFloat
  126.   },
  127.   { // 12
  128.     Type::Double,
  129.     cmpDouble
  130.   },
  131.   { // 13
  132.     Type::Olddecimal,
  133.     cmpOlddecimal
  134.   },
  135.   { // 14
  136.     Type::Char,
  137.     cmpChar
  138.   },
  139.   { // 15
  140.     Type::Varchar,
  141.     cmpVarchar
  142.   },
  143.   { // 16
  144.     Type::Binary,
  145.     cmpBinary
  146.   },
  147.   { // 17
  148.     Type::Varbinary,
  149.     cmpVarbinary
  150.   },
  151.   { // 18
  152.     Type::Datetime,
  153.     cmpDatetime
  154.   },
  155.   { // 19
  156.     Type::Date,
  157.     cmpDate
  158.   },
  159.   { // 20
  160.     Type::Blob,
  161.     cmpBlob
  162.   },
  163.   { // 21
  164.     Type::Text,
  165.     cmpText
  166.   },
  167.   { // 22
  168.     Type::Undefined,    // 5.0 Bit
  169.     NULL
  170.   },
  171.   { // 23
  172.     Type::Undefined,    // 5.0 Longvarchar
  173.     NULL
  174.   },
  175.   { // 24
  176.     Type::Undefined,    // 5.0 Longvarbinary
  177.     NULL
  178.   },
  179.   { // 25
  180.     Type::Time,
  181.     cmpTime
  182.   },
  183.   { // 26
  184.     Type::Year,
  185.     cmpYear
  186.   },
  187.   { // 27
  188.     Type::Timestamp,
  189.     cmpTimestamp
  190.   },
  191.   { // 28
  192.     Type::Olddecimalunsigned,
  193.     cmpOlddecimalunsigned
  194.   }
  195. };
  197. const NdbSqlUtil::Type&
  198. NdbSqlUtil::getType(Uint32 typeId)
  199. {
  200.   if (typeId < sizeof(m_typeList) / sizeof(m_typeList[0]) &&
  201.       m_typeList[typeId].m_typeId != Type::Undefined) {
  202.     return m_typeList[typeId];
  203.   }
  204.   return m_typeList[Type::Undefined];
  205. }
  207. const NdbSqlUtil::Type&
  208. NdbSqlUtil::getTypeBinary(Uint32 typeId)
  209. {
  210.   switch (typeId) {
  211.   case Type::Char:
  212.     typeId = Type::Binary;
  213.     break;
  214.   case Type::Varchar:
  215.     typeId = Type::Varbinary; 
  216.     break;
  217.   case Type::Text:
  218.     typeId = Type::Blob;
  219.     break;
  220.   default:
  221.     break;
  222.   }
  223.   return getType(typeId);
  224. }
  226. // compare
  228. int
  229. NdbSqlUtil::cmpTinyint(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  230. {
  231.   assert(full >= size && size > 0);
  232.   union { Uint32 p[1]; Int8 v; } u1, u2;
  233.   u1.p[0] = p1[0];
  234.   u2.p[0] = p2[0];
  235.   if (u1.v < u2.v)
  236.     return -1;
  237.   if (u1.v > u2.v)
  238.     return +1;
  239.   return 0;
  240. }
  242. int
  243. NdbSqlUtil::cmpTinyunsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  244. {
  245.   assert(full >= size && size > 0);
  246.   union { Uint32 p[1]; Uint8 v; } u1, u2;
  247.   u1.p[0] = p1[0];
  248.   u2.p[0] = p2[0];
  249.   if (u1.v < u2.v)
  250.     return -1;
  251.   if (u1.v > u2.v)
  252.     return +1;
  253.   return 0;
  254. }
  256. int
  257. NdbSqlUtil::cmpSmallint(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  258. {
  259.   assert(full >= size && size > 0);
  260.   union { Uint32 p[1]; Int16 v; } u1, u2;
  261.   u1.p[0] = p1[0];
  262.   u2.p[0] = p2[0];
  263.   if (u1.v < u2.v)
  264.     return -1;
  265.   if (u1.v > u2.v)
  266.     return +1;
  267.   return 0;
  268. }
  270. int
  271. NdbSqlUtil::cmpSmallunsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  272. {
  273.   assert(full >= size && size > 0);
  274.   union { Uint32 p[1]; Uint16 v; } u1, u2;
  275.   u1.p[0] = p1[0];
  276.   u2.p[0] = p2[0];
  277.   if (u1.v < u2.v)
  278.     return -1;
  279.   if (u1.v > u2.v)
  280.     return +1;
  281.   return 0;
  282. }
  284. int
  285. NdbSqlUtil::cmpMediumint(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  286. {
  287.   assert(full >= size && size > 0);
  288.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  289.   u1.p = p1;
  290.   u2.p = p2;
  291.   Int32 v1 = sint3korr(u1.v);
  292.   Int32 v2 = sint3korr(u2.v);
  293.   if (v1 < v2)
  294.     return -1;
  295.   if (v1 > v2)
  296.     return +1;
  297.   return 0;
  298. }
  300. int
  301. NdbSqlUtil::cmpMediumunsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  302. {
  303.   assert(full >= size && size > 0);
  304.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  305.   u1.p = p1;
  306.   u2.p = p2;
  307.   Uint32 v1 = uint3korr(u1.v);
  308.   Uint32 v2 = uint3korr(u2.v);
  309.   if (v1 < v2)
  310.     return -1;
  311.   if (v1 > v2)
  312.     return +1;
  313.   return 0;
  314. }
  316. int
  317. NdbSqlUtil::cmpInt(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  318. {
  319.   assert(full >= size && size > 0);
  320.   union { Uint32 p[1]; Int32 v; } u1, u2;
  321.   u1.p[0] = p1[0];
  322.   u2.p[0] = p2[0];
  323.   if (u1.v < u2.v)
  324.     return -1;
  325.   if (u1.v > u2.v)
  326.     return +1;
  327.   return 0;
  328. }
  330. int
  331. NdbSqlUtil::cmpUnsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  332. {
  333.   assert(full >= size && size > 0);
  334.   union { Uint32 p[1]; Uint32 v; } u1, u2;
  335.   u1.v = p1[0];
  336.   u2.v = p2[0];
  337.   if (u1.v < u2.v)
  338.     return -1;
  339.   if (u1.v > u2.v)
  340.     return +1;
  341.   return 0;
  342. }
  344. int
  345. NdbSqlUtil::cmpBigint(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  346. {
  347.   assert(full >= size && size > 0);
  348.   if (size >= 2) {
  349.     union { Uint32 p[2]; Int64 v; } u1, u2;
  350.     u1.p[0] = p1[0];
  351.     u1.p[1] = p1[1];
  352.     u2.p[0] = p2[0];
  353.     u2.p[1] = p2[1];
  354.     if (u1.v < u2.v)
  355.       return -1;
  356.     if (u1.v > u2.v)
  357.       return +1;
  358.     return 0;
  359.   }
  360.   return CmpUnknown;
  361. }
  363. int
  364. NdbSqlUtil::cmpBigunsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  365. {
  366.   assert(full >= size && size > 0);
  367.   if (size >= 2) {
  368.     union { Uint32 p[2]; Uint64 v; } u1, u2;
  369.     u1.p[0] = p1[0];
  370.     u1.p[1] = p1[1];
  371.     u2.p[0] = p2[0];
  372.     u2.p[1] = p2[1];
  373.     if (u1.v < u2.v)
  374.       return -1;
  375.     if (u1.v > u2.v)
  376.       return +1;
  377.     return 0;
  378.   }
  379.   return CmpUnknown;
  380. }
  382. int
  383. NdbSqlUtil::cmpFloat(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  384. {
  385.   assert(full >= size && size > 0);
  386.   union { Uint32 p[1]; float v; } u1, u2;
  387.   u1.p[0] = p1[0];
  388.   u2.p[0] = p2[0];
  389.   // no format check
  390.   if (u1.v < u2.v)
  391.     return -1;
  392.   if (u1.v > u2.v)
  393.     return +1;
  394.   return 0;
  395. }
  397. int
  398. NdbSqlUtil::cmpDouble(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  399. {
  400.   assert(full >= size && size > 0);
  401.   if (size >= 2) {
  402.     union { Uint32 p[2]; double v; } u1, u2;
  403.     u1.p[0] = p1[0];
  404.     u1.p[1] = p1[1];
  405.     u2.p[0] = p2[0];
  406.     u2.p[1] = p2[1];
  407.     // no format check
  408.     if (u1.v < u2.v)
  409.       return -1;
  410.     if (u1.v > u2.v)
  411.       return +1;
  412.     return 0;
  413.   }
  414.   return CmpUnknown;
  415. }
  417. int
  418. NdbSqlUtil::cmp_olddecimal(const uchar* s1, const uchar* s2, unsigned n)
  419. {
  420.   int sgn = +1;
  421.   unsigned i = 0;
  422.   while (i < n) {
  423.     int c1 = s1[i];
  424.     int c2 = s2[i];
  425.     if (c1 == c2) {
  426.       if (c1 == '-')
  427.         sgn = -1;
  428.     } else if (c1 == '-') {
  429.       return -1;
  430.     } else if (c2 == '-') {
  431.       return +1;
  432.     } else if (c1 < c2) {
  433.       return -1 * sgn;
  434.     } else {
  435.       return +1 * sgn;
  436.     }
  437.     i++;
  438.   }
  439.   return 0;
  440. }
  442. int
  443. NdbSqlUtil::cmpOlddecimal(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  444. {
  445.   assert(full >= size && size > 0);
  446.   if (full == size) {
  447.     union { const Uint32* p; const uchar* v; } u1, u2;
  448.     u1.p = p1;
  449.     u2.p = p2;
  450.     return cmp_olddecimal(u1.v, u2.v, full << 2);
  451.   }
  452.   return CmpUnknown;
  453. }
  455. int
  456. NdbSqlUtil::cmpOlddecimalunsigned(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  457. {
  458.   assert(full >= size && size > 0);
  459.   if (full == size) {
  460.     union { const Uint32* p; const uchar* v; } u1, u2;
  461.     u1.p = p1;
  462.     u2.p = p2;
  463.     return cmp_olddecimal(u1.v, u2.v, full << 2);
  464.   }
  465.   return CmpUnknown;
  466. }
  468. int
  469. NdbSqlUtil::cmpChar(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  470. {
  471.   // collation does not work on prefix for some charsets
  472.   assert(full == size && size > 0);
  473.   /*
  474.    * Char is blank-padded to length and null-padded to word size.
  475.    */
  476.   union { const Uint32* p; const uchar* v; } u1, u2;
  477.   u1.p = p1;
  478.   u2.p = p2;
  479.   // not const in MySQL
  480.   CHARSET_INFO* cs = (CHARSET_INFO*)(info);
  481.   // length in bytes including null padding to Uint32
  482.   uint l1 = (full << 2);
  483.   int k = (*cs->coll->strnncollsp)(cs, u1.v, l1, u2.v, l1);
  484.   return k < 0 ? -1 : k > 0 ? +1 : 0;
  485. }
  487. int
  488. NdbSqlUtil::cmpVarchar(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  489. {
  490.   assert(full >= size && size > 0);
  491.   /*
  492.    * Varchar is not allowed to contain a null byte and the value is
  493.    * null-padded.  Therefore comparison does not need to use the length.
  494.    *
  495.    * Not used before MySQL 5.0.  Format is likely to change.  Handle
  496.    * only binary collation for now.
  497.    */
  498.   union { const Uint32* p; const char* v; } u1, u2;
  499.   u1.p = p1;
  500.   u2.p = p2;
  501.   // skip length in first 2 bytes
  502.   int k = strncmp(u1.v + 2, u2.v + 2, (size << 2) - 2);
  503.   return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown;
  504. }
  506. int
  507. NdbSqlUtil::cmpBinary(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  508. {
  509.   assert(full >= size && size > 0);
  510.   /*
  511.    * Binary data of full length.  Compare bytewise.
  512.    */
  513.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  514.   u1.p = p1;
  515.   u2.p = p2;
  516.   int k = memcmp(u1.v, u2.v, size << 2);
  517.   return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown;
  518. }
  520. int
  521. NdbSqlUtil::cmpVarbinary(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  522. {
  523.   assert(full >= size && size > 0);
  524.   /*
  525.    * Binary data of variable length padded with nulls.  The comparison
  526.    * does not need to use the length.
  527.    *
  528.    * Not used before MySQL 5.0.  Format is likely to change.
  529.    */
  530.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  531.   u1.p = p1;
  532.   u2.p = p2;
  533.   // skip length in first 2 bytes
  534.   int k = memcmp(u1.v + 2, u2.v + 2, (size << 2) - 2);
  535.   return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown;
  536. }
  538. int
  539. NdbSqlUtil::cmpDatetime(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  540. {
  541.   assert(full >= size && size > 0);
  542.   if (size >= 2) {
  543.     union { Uint32 p[2]; Int64 v; } u1, u2;
  544.     u1.p[0] = p1[0];
  545.     u1.p[1] = p1[1];
  546.     u2.p[0] = p2[0];
  547.     u2.p[1] = p2[1];
  548.     if (u1.v < u2.v)
  549.       return -1;
  550.     if (u1.v > u2.v)
  551.       return +1;
  552.     return 0;
  553.   }
  554.   return CmpUnknown;
  555. }
  557. int
  558. NdbSqlUtil::cmpDate(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  559. {
  560. #ifdef ndb_date_is_4_byte_native_int
  561.   assert(full >= size && size > 0);
  562.   union { Uint32 p[2]; Int32 v; } u1, u2;
  563.   u1.p[0] = p1[0];
  564.   u2.p[0] = p2[0];
  565.   if (u1.v < u2.v)
  566.     return -1;
  567.   if (u1.v > u2.v)
  568.     return +1;
  569.   return 0;
  570. #else
  571.   assert(full >= size && size > 0);
  572.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  573.   u1.p = p1;
  574.   u2.p = p2;
  575. #ifdef ndb_date_sol9x86_cc_xO3_madness
  576.   // from Field_newdate::val_int
  577.   Uint64 j1 = uint3korr(u1.v);
  578.   Uint64 j2 = uint3korr(u2.v);
  579.   j1 = (j1 % 32L)+(j1 / 32L % 16L)*100L + (j1/(16L*32L))*10000L;
  580.   j2 = (j2 % 32L)+(j2 / 32L % 16L)*100L + (j2/(16L*32L))*10000L;
  581.   if (j1 < j2)
  582.     return -1;
  583.   if (j1 > j2)
  584.     return +1;
  585.   return 0;
  586. #else
  587.   uint j1 = uint3korr(u1.v);
  588.   uint j2 = uint3korr(u2.v);
  589.   uint d1 = (j1 & 31);
  590.   uint d2 = (j2 & 31);
  591.   j1 = (j1 >> 5);
  592.   j2 = (j2 >> 5);
  593.   uint m1 = (j1 & 15);
  594.   uint m2 = (j2 & 15);
  595.   j1 = (j1 >> 4);
  596.   j2 = (j2 >> 4);
  597.   uint y1 = j1;
  598.   uint y2 = j2;
  599.   if (y1 < y2)
  600.     return -1;
  601.   if (y1 > y2)
  602.     return +1;
  603.   if (m1 < m2)
  604.     return -1;
  605.   if (m1 > m2)
  606.     return +1;
  607.   if (d1 < d2)
  608.     return -1;
  609.   if (d1 > d2)
  610.     return +1;
  611.   return 0;
  612. #endif
  613. #endif
  614. }
  616. int
  617. NdbSqlUtil::cmpBlob(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  618. {
  619.   assert(full >= size && size > 0);
  620.   /*
  621.    * Blob comparison is on the inline bytes (null padded).
  622.    */
  623.   const unsigned head = NDB_BLOB_HEAD_SIZE;
  624.   // skip blob head
  625.   if (size >= head + 1) {
  626.     union { const Uint32* p; const unsigned char* v; } u1, u2;
  627.     u1.p = p1 + head;
  628.     u2.p = p2 + head;
  629.     int k = memcmp(u1.v, u2.v, (size - head) << 2);
  630.     return k < 0 ? -1 : k > 0 ? +1 : full == size ? 0 : CmpUnknown;
  631.   }
  632.   return CmpUnknown;
  633. }
  635. int
  636. NdbSqlUtil::cmpText(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  637. {
  638.   // collation does not work on prefix for some charsets
  639.   assert(full == size && size > 0);
  640.   /*
  641.    * Text comparison is on the inline bytes (blank padded).  Currently
  642.    * not supported for multi-byte charsets.
  643.    */
  644.   const unsigned head = NDB_BLOB_HEAD_SIZE;
  645.   // skip blob head
  646.   if (size >= head + 1) {
  647.     union { const Uint32* p; const uchar* v; } u1, u2;
  648.     u1.p = p1 + head;
  649.     u2.p = p2 + head;
  650.     // not const in MySQL
  651.     CHARSET_INFO* cs = (CHARSET_INFO*)(info);
  652.     // length in bytes including null padding to Uint32
  653.     uint l1 = (full << 2);
  654.     int k = (*cs->coll->strnncollsp)(cs, u1.v, l1, u2.v, l1);
  655.     return k < 0 ? -1 : k > 0 ? +1 : 0;
  656.   }
  657.   return CmpUnknown;
  658. }
  660. int
  661. NdbSqlUtil::cmpTime(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  662. {
  663.   assert(full >= size && size > 0);
  664.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  665.   u1.p = p1;
  666.   u2.p = p2;
  667.   // from Field_time::val_int
  668.   Int32 j1 = sint3korr(u1.v);
  669.   Int32 j2 = sint3korr(u2.v);
  670.   if (j1 < j2)
  671.     return -1;
  672.   if (j1 > j2)
  673.     return +1;
  674.   return 0;
  675. }
  677. int
  678. NdbSqlUtil::cmpYear(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  679. {
  680.   assert(full >= size && size > 0);
  681.   union { const Uint32* p; const unsigned char* v; } u1, u2;
  682.   u1.p = p1;
  683.   u2.p = p2;
  684.   if (u1.v[0] < u2.v[0])
  685.     return -1;
  686.   if (u1.v[0] > u2.v[0])
  687.     return +1;
  688.   return 0;
  689. }
  691. int
  692. NdbSqlUtil::cmpTimestamp(const void* info, const Uint32* p1, const Uint32* p2, Uint32 full, Uint32 size)
  693. {
  694.   assert(full >= size && size > 0);
  695.   union { Uint32 p[1]; Uint32 v; } u1, u2;
  696.   u1.v = p1[0];
  697.   u2.v = p2[0];
  698.   if (u1.v < u2.v)
  699.     return -1;
  700.   if (u1.v > u2.v)
  701.     return +1;
  702.   return 0;
  703. }
  705. // check charset
  707. bool
  708. NdbSqlUtil::usable_in_pk(Uint32 typeId, const void* info)
  709. {
  710.   const Type& type = getType(typeId);
  711.   switch (type.m_typeId) {
  712.   case Type::Undefined:
  713.     break;
  714.   case Type::Char:
  715.     {
  716.       const CHARSET_INFO *cs = (const CHARSET_INFO*)info;
  717.       return
  718.         cs != 0 &&
  719.         cs->cset != 0 &&
  720.         cs->coll != 0 &&
  721.         cs->coll->strnxfrm != 0 &&
  722.         cs->strxfrm_multiply <= 1; // current limitation
  723.     }
  724.     break;
  725.   case Type::Varchar:
  726.     return true; // Varchar not used via MySQL
  727.   case Type::Blob:
  728.   case Type::Text:
  729.     break;
  730.   default:
  731.     return true;
  732.   }
  733.   return false;
  734. }
  736. bool
  737. NdbSqlUtil::usable_in_hash_index(Uint32 typeId, const void* info)
  738. {
  739.   return usable_in_pk(typeId, info);
  740. }
  742. bool
  743. NdbSqlUtil::usable_in_ordered_index(Uint32 typeId, const void* info)
  744. {
  745.   const Type& type = getType(typeId);
  746.   switch (type.m_typeId) {
  747.   case Type::Undefined:
  748.     break;
  749.   case Type::Char:
  750.     {
  751.       const CHARSET_INFO *cs = (const CHARSET_INFO*)info;
  752.       return
  753.         cs != 0 &&
  754.         cs->cset != 0 &&
  755.         cs->coll != 0 &&
  756.         cs->coll->strnxfrm != 0 &&
  757.         cs->coll->strnncollsp != 0 &&
  758.         cs->strxfrm_multiply <= 1; // current limitation
  759.     }
  760.     break;
  761.   case Type::Varchar:
  762.     return true; // Varchar not used via MySQL
  763.   case Type::Text:
  764.     {
  765.       const CHARSET_INFO *cs = (const CHARSET_INFO*)info;
  766.       return
  767.         cs != 0 &&
  768.         cs->mbmaxlen == 1 && // extra limitation
  769.         cs->cset != 0 &&
  770.         cs->coll != 0 &&
  771.         cs->coll->strnxfrm != 0 &&
  772.         cs->coll->strnncollsp != 0 &&
  773.         cs->strxfrm_multiply <= 1; // current limitation
  774.     }
  775.     break;
  776.   default:
  777.     return true;
  778.   }
  779.   return false;
  780. }
  782. #ifdef NDB_SQL_UTIL_TEST
  784. #include <NdbTick.h>
  785. #include <NdbOut.hpp>
  787. struct Testcase {
  788.   int op;       // 1=compare 2=like
  789.   int res;
  790.   const char* s1;
  791.   const char* s2;
  792.   int pad;
  793. };
  794. const Testcase testcase[] = {
  795.   { 2, 1, "abc", "abc", 0 },
  796.   { 2, 1, "abc", "abc%", 0 },
  797.   { 2, 1, "abcdef", "abc%", 0 },
  798.   { 2, 1, "abcdefabcdefabcdef", "abc%", 0 },
  799.   { 2, 1, "abcdefabcdefabcdef", "abc%f", 0 },
  800.   { 2, 0, "abcdefabcdefabcdef", "abc%z", 0 },
  801.   { 2, 1, "abcdefabcdefabcdef", "%f", 0 },
  802.   { 2, 1, "abcdef", "a%b%c%d%e%f", 0 },
  803.   { 0, 0, 0, 0 }
  804. };
  806. int
  807. main(int argc, char** argv)
  808. {
  809.   ndb_init(); // for charsets
  810.   unsigned count = argc > 1 ? atoi(argv[1]) : 1000000;
  811.   ndbout_c("count = %u", count);
  812.   assert(count != 0);
  813.   for (const Testcase* t = testcase; t->s1 != 0; t++) {
  814.     ndbout_c("%d = '%s' %s '%s' pad=%d",
  815.         t->res, t->s1, t->op == 1 ? "comp" : "like", t->s2);
  816.     NDB_TICKS x1 = NdbTick_CurrentMillisecond();
  817.     unsigned n1 = strlen(t->s1);
  818.     unsigned n2 = strlen(t->s2);
  819.     for (unsigned i = 0; i < count; i++) {
  820.       if (t->op == 1) {
  821.         int res = NdbSqlUtil::char_compare(t->s1, n1, t->s2, n2, t->pad);
  822.         assert(res == t->res);
  823.         continue;
  824.       }
  825.       if (t->op == 2) {
  826.         int res = NdbSqlUtil::char_like(t->s1, n1, t->s2, n2, t->pad);
  827.         assert(res == t->res);
  828.         continue;
  829.       }
  830.       assert(false);
  831.     }
  832.     NDB_TICKS x2 = NdbTick_CurrentMillisecond();
  833.     if (x2 < x1)
  834.       x2 = x1;
  835.     double usec = 1000000.0 * double(x2 - x1) / double(count);
  836.     ndbout_c("time %.0f usec per call", usec);
  837.   }
  838.   // quick check
  839.   for (unsigned i = 0; i < sizeof(m_typeList) / sizeof(m_typeList[0]); i++) {
  840.     const NdbSqlUtil::Type& t = m_typeList[i];
  841.     assert(t.m_typeId == i);
  842.   }
  843.   return 0;
  844. }
  846. #endif