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

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

MySQL数据库

开发平台：

Visual C++

DataField.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 "DataField.hpp"
  19. #ifndef INT_MAX
  20. #define INT_MAX (2147483647)
  21. #endif
  23. #ifndef INT_MIN
  24. #define INT_MIN (-INT_MAX - 1)
  25. #endif
  27. #ifndef UINT_MAX
  28. #define UINT_MAX 4294967295U
  29. #endif
  31. #ifndef FLT_MAX
  32. #define FLT_MAX (3.402823466E+38F)
  33. #endif
  34. #ifndef FLT_MIN
  35. #define FLT_MIN (1.175494351E-38F)
  36. #endif
  38. #ifdef NDB_WIN32
  39. #define FMT_I64 "%I64d"
  40. #define FMT_U64 "%I64u"
  41. #else
  42. #define FMT_I64 "%lld"
  43. #define FMT_U64 "%llu"
  44. #endif
  46. #ifdef NDB_WIN32
  47. #define strtoll(str, endptr, base) strtoint64(str, endptr, base)
  48. #define strtoull(str, endptr, base) strtouint64(str, endptr, base)
  50. static Int64
  51. strtoint64(const char *str, char **endptr, int base)
  52. {
  53.     Int64 x = 0;
  54.     while (*str == ' ')
  55. str++;
  56.     const char* p = str;
  57.     while ('0' <= *p && *p <= '9')
  58. x = 10 * x + *p++ - '0';
  59.     if (p == str) {
  60. *endptr = 0;
  61. return 0;
  62.     }
  63.     *endptr = (char*)p;
  64.     return x;
  65. }
  67. static Uint64
  68. strtouint64(const char *str, char **endptr, int base)
  69. {
  70.     Uint64 x = 0;
  71.     while (*str == ' ')
  72. str++;
  73.     const char* p = str;
  74.     while ('0' <= *p && *p <= '9')
  75. x = 10 * x + *p++ - '0';
  76.     if (p == str) {
  77. *endptr = 0;
  78. return 0;
  79.     }
  80.     *endptr = (char*)p;
  81.     return x;
  82. }
  83. #endif
  85. // LexSpec
  87. void
  88. LexSpec::convert(Ctx& ctx, const BaseString& value, SqlField& out)
  89. {
  90.     const SqlSpec& sqlSpec = out.sqlSpec();
  91.     const SqlType& sqlType = sqlSpec.sqlType();
  92.     out.alloc();
  93.     if (sqlType.type() == SqlType::Char) {
  94. const SqlChar* s = (const SqlChar*)value.c_str();
  95. out.sqlChar(s, SQL_NTS);
  96. return;
  97.     }
  98.     if (sqlType.type() == SqlType::Bigint) {
  99. char* endptr = 0;
  100. SqlBigint n = static_cast<SqlBigint>(strtoll(value.c_str(), &endptr, 10));
  101. if (endptr == 0 || *endptr != 0) {
  102.     ctx.pushStatus(Error::Gen, "cannot convert '%s' to integer", value.c_str());
  103.     return;
  104. }
  105. out.sqlBigint(n);
  106. return;
  107.     }
  108.     if (sqlType.type() == SqlType::Double) {
  109. char* endptr = 0;
  110. SqlDouble x = static_cast<SqlDouble>(strtod(value.c_str(), &endptr));
  111. if (endptr == 0 || *endptr != 0) {
  112.     ctx.pushStatus(Error::Gen, "cannot convert '%s' to number", value.c_str());
  113.     return;
  114. }
  115. out.sqlDouble(x);
  116. return;
  117.     }
  118.     if (sqlType.type() == SqlType::Null) {
  119. out.u_null.m_nullFlag = true;
  120. return;
  121.     }
  122.     ctx_assert(false);
  123. }
  125. // SqlField
  127. void
  128. SqlField::alloc()
  129. {
  130.     ctx_assert(sqlSpec().store() == SqlSpec::Physical);
  131.     const SqlType& sqlType = sqlSpec().sqlType();
  132.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  133. unsigned n = sqlType.length();
  134. if (sqlType.type() == SqlType::Varchar)
  135.     n += 2;
  136. if (n > SqlField_CharSmall) {
  137.     u_data.m_sqlChar = new SqlChar[n];
  138. }
  139.     }
  140.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  141. unsigned n = sqlType.length();
  142. if (sqlType.type() == SqlType::Varbinary)
  143.     n += 2;
  144. if (n > SqlField_CharSmall) {
  145.     u_data.m_sqlChar = new SqlChar[n];
  146. }
  147.     }
  148. }
  150. void
  151. SqlField::alloc(const SqlField& sqlField)
  152. {
  153.     alloc();
  154.     const SqlType& sqlType = sqlSpec().sqlType();
  155.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  156. unsigned n = sqlType.length();
  157. if (sqlType.type() == SqlType::Varchar)
  158.     n += 2;
  159. if (n > SqlField_CharSmall) {
  160.     memcpy(u_data.m_sqlChar, sqlField.u_data.m_sqlChar, n);
  161. }
  162.     }
  163.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  164. unsigned n = sqlType.length();
  165. if (sqlType.type() == SqlType::Varbinary)
  166.     n += 2;
  167. if (n > SqlField_CharSmall) {
  168.     memcpy(u_data.m_sqlChar, sqlField.u_data.m_sqlChar, n);
  169. }
  170.     }
  171. }
  173. const void*
  174. SqlField::addr() const
  175. {
  176.     if (sqlSpec().store() == SqlSpec::Reference) {
  177. ctx_assert(u_data.m_sqlField != 0);
  178. return u_data.m_sqlField->addr();
  179.     }
  180.     const SqlType& sqlType = sqlSpec().sqlType();
  181.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  182. unsigned n = sqlType.length();
  183. if (sqlType.type() == SqlType::Varchar)
  184.     n += 2;
  185. if (n > SqlField_CharSmall) {
  186.     return static_cast<const void*>(u_data.m_sqlChar);
  187. }
  188. return static_cast<const void*>(u_data.m_sqlCharSmall);
  189.     }
  190.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  191. unsigned n = sqlType.length();
  192. if (sqlType.type() == SqlType::Varbinary)
  193.     n += 2;
  194. if (n > SqlField_CharSmall) {
  195.     return static_cast<const void*>(u_data.m_sqlChar);
  196. }
  197. return static_cast<const void*>(u_data.m_sqlCharSmall);
  198.     }
  199.     if (sqlType.type() == SqlType::Smallint) {
  200. return static_cast<const void*>(&u_data.m_sqlSmallint);
  201.     }
  202.     if (sqlType.type() == SqlType::Integer) {
  203. return static_cast<const void*>(&u_data.m_sqlInteger);
  204.     }
  205.     if (sqlType.type() == SqlType::Bigint) {
  206. return static_cast<const void*>(&u_data.m_sqlBigint);
  207.     }
  208.     if (sqlType.type() == SqlType::Real) {
  209. return static_cast<const void*>(&u_data.m_sqlReal);
  210.     }
  211.     if (sqlType.type() == SqlType::Double) {
  212. return static_cast<const void*>(&u_data.m_sqlDouble);
  213.     }
  214.     if (sqlType.type() == SqlType::Datetime) {
  215. return static_cast<const void*>(&u_data.m_sqlDatetime);
  216.     }
  217.     ctx_assert(false); // SqlType::Null has no address
  218.     return 0;
  219. }
  221. void*
  222. SqlField::addr()
  223. {
  224.     const SqlType& sqlType = sqlSpec().sqlType();
  225.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  226. unsigned n = sqlType.length();
  227. if (sqlType.type() == SqlType::Varchar)
  228.     n += 2;
  229. if (n > SqlField_CharSmall) {
  230.     return static_cast<void*>(u_data.m_sqlChar);
  231. }
  232. return static_cast<void*>(u_data.m_sqlCharSmall);
  233.     }
  234.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  235. unsigned n = sqlType.length();
  236. if (sqlType.type() == SqlType::Varbinary)
  237.     n += 2;
  238. if (n > SqlField_CharSmall) {
  239.     return static_cast<void*>(u_data.m_sqlChar);
  240. }
  241. return static_cast<void*>(u_data.m_sqlCharSmall);
  242.     }
  243.     if (sqlType.type() == SqlType::Smallint) {
  244. return static_cast<void*>(&u_data.m_sqlSmallint);
  245.     }
  246.     if (sqlType.type() == SqlType::Integer) {
  247. return static_cast<void*>(&u_data.m_sqlInteger);
  248.     }
  249.     if (sqlType.type() == SqlType::Bigint) {
  250. return static_cast<void*>(&u_data.m_sqlBigint);
  251.     }
  252.     if (sqlType.type() == SqlType::Real) {
  253. return static_cast<void*>(&u_data.m_sqlReal);
  254.     }
  255.     if (sqlType.type() == SqlType::Double) {
  256. return static_cast<void*>(&u_data.m_sqlDouble);
  257.     }
  258.     if (sqlType.type() == SqlType::Datetime) {
  259. return static_cast<void*>(&u_data.m_sqlDatetime);
  260.     }
  261.     ctx_assert(false); // SqlType::Null has no address
  262.     return 0;
  263. }
  265. unsigned
  266. SqlField::allocSize() const
  267. {
  268.     const SqlType& sqlType = sqlSpec().sqlType();
  269.     unsigned n = sqlType.size();
  270.     if (sqlType.type() == SqlType::Varchar || sqlType.type() == SqlType::Varbinary) {
  271. n += 2;
  272.     }
  273.     return n;
  274. }
  276. void
  277. SqlField::free()
  278. {
  279.     ctx_assert(sqlSpec().store() == SqlSpec::Physical);
  280.     const SqlType& sqlType = sqlSpec().sqlType();
  281.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  282. unsigned n = sqlType.length();
  283. if (sqlType.type() == SqlType::Varchar)
  284.     n += 2;
  285. if (n > SqlField_CharSmall) {
  286.     delete[] u_data.m_sqlChar;
  287.     u_data.m_sqlChar = 0; // safety since dtor used explicitly
  288. }
  289.     }
  290.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  291. unsigned n = sqlType.length();
  292. if (sqlType.type() == SqlType::Varbinary)
  293.     n += 2;
  294. if (n > SqlField_CharSmall) {
  295.     delete[] u_data.m_sqlChar;
  296.     u_data.m_sqlChar = 0; // safety since dtor used explicitly
  297. }
  298.     }
  299. }
  301. // get
  303. const SqlChar*
  304. SqlField::sqlChar() const
  305. {
  306.     if (sqlSpec().store() == SqlSpec::Reference) {
  307. ctx_assert(u_data.m_sqlField != 0);
  308. return u_data.m_sqlField->sqlChar();
  309.     }
  310.     const SqlType& sqlType = sqlSpec().sqlType();
  311.     ctx_assert(sqlType.type() == SqlType::Char);
  312.     if (sqlType.length() > SqlField_CharSmall)
  313. return u_data.m_sqlChar;
  314.     return u_data.m_sqlCharSmall;
  315. }
  317. const SqlChar*
  318. SqlField::sqlVarchar(unsigned* length) const
  319. {
  320. #if NDB_VERSION_MAJOR >= 3
  321.     if (sqlSpec().store() == SqlSpec::Reference) {
  322. ctx_assert(u_data.m_sqlField != 0);
  323. return u_data.m_sqlField->sqlVarchar(length);
  324.     }
  325.     const SqlType& sqlType = sqlSpec().sqlType();
  326.     ctx_assert(sqlType.type() == SqlType::Varchar);
  327.     const SqlChar* sqlChar;
  328.     unsigned n = sqlType.length();
  329.     if (2 + n > SqlField_CharSmall)
  330. sqlChar = u_data.m_sqlChar;
  331.     else
  332. sqlChar = u_data.m_sqlCharSmall;
  333.     if (length != 0)
  334. *length = (sqlChar[0] << 8) | sqlChar[1]; // big-endian
  335.     return sqlChar + 2;
  336. #else
  337.     if (sqlSpec().store() == SqlSpec::Reference) {
  338. ctx_assert(u_data.m_sqlField != 0);
  339. return u_data.m_sqlField->sqlVarchar(length);
  340.     }
  341.     const SqlType& sqlType = sqlSpec().sqlType();
  342.     ctx_assert(sqlType.type() == SqlType::Varchar);
  343.     const SqlChar* sqlChar;
  344.     unsigned n = sqlType.length();
  345.     if (n + 2 > SqlField_CharSmall)
  346. sqlChar = u_data.m_sqlChar;
  347.     else
  348. sqlChar = u_data.m_sqlCharSmall;
  349.     if (length != 0)
  350. *length = (sqlChar[n + 0] << 8) | sqlChar[n + 1]; // big-endian
  351.     return sqlChar;
  352. #endif
  353. }
  355. const SqlChar*
  356. SqlField::sqlBinary() const
  357. {
  358.     if (sqlSpec().store() == SqlSpec::Reference) {
  359. ctx_assert(u_data.m_sqlField != 0);
  360. return u_data.m_sqlField->sqlChar();
  361.     }
  362.     const SqlType& sqlType = sqlSpec().sqlType();
  363.     ctx_assert(sqlType.type() == SqlType::Binary);
  364.     if (sqlType.length() > SqlField_CharSmall)
  365. return u_data.m_sqlChar;
  366.     return u_data.m_sqlCharSmall;
  367. }
  369. const SqlChar*
  370. SqlField::sqlVarbinary(unsigned* length) const
  371. {
  372. #if NDB_VERSION_MAJOR >= 3
  373.     if (sqlSpec().store() == SqlSpec::Reference) {
  374. ctx_assert(u_data.m_sqlField != 0);
  375. return u_data.m_sqlField->sqlVarchar(length);
  376.     }
  377.     const SqlType& sqlType = sqlSpec().sqlType();
  378.     ctx_assert(sqlType.type() == SqlType::Varbinary);
  379.     const SqlChar* sqlChar;
  380.     unsigned n = sqlType.length();
  381.     if (2 + n > SqlField_CharSmall)
  382. sqlChar = u_data.m_sqlChar;
  383.     else
  384. sqlChar = u_data.m_sqlCharSmall;
  385.     if (length != 0)
  386. *length = (sqlChar[0] << 8) | sqlChar[1]; // big-endian
  387.     return sqlChar + 2;
  388. #else
  389.     if (sqlSpec().store() == SqlSpec::Reference) {
  390. ctx_assert(u_data.m_sqlField != 0);
  391. return u_data.m_sqlField->sqlVarchar(length);
  392.     }
  393.     const SqlType& sqlType = sqlSpec().sqlType();
  394.     ctx_assert(sqlType.type() == SqlType::Varbinary);
  395.     const SqlChar* sqlChar;
  396.     unsigned n = sqlType.length();
  397.     if (n + 2 > SqlField_CharSmall)
  398. sqlChar = u_data.m_sqlChar;
  399.     else
  400. sqlChar = u_data.m_sqlCharSmall;
  401.     if (length != 0)
  402. *length = (sqlChar[n + 0] << 8) | sqlChar[n + 1]; // big-endian
  403.     return sqlChar;
  404. #endif
  405. }
  407. SqlSmallint
  408. SqlField::sqlSmallint() const
  409. {
  410.     if (sqlSpec().store() == SqlSpec::Reference) {
  411. ctx_assert(u_data.m_sqlField != 0);
  412. return u_data.m_sqlField->sqlSmallint();
  413.     }
  414.     const SqlType& sqlType = sqlSpec().sqlType();
  415.     ctx_assert(sqlType.type() == SqlType::Smallint);
  416.     return u_data.m_sqlSmallint;
  417. }
  419. SqlInteger
  420. SqlField::sqlInteger() const
  421. {
  422.     if (sqlSpec().store() == SqlSpec::Reference) {
  423. ctx_assert(u_data.m_sqlField != 0);
  424. return u_data.m_sqlField->sqlInteger();
  425.     }
  426.     const SqlType& sqlType = sqlSpec().sqlType();
  427.     ctx_assert(sqlType.type() == SqlType::Integer);
  428.     return u_data.m_sqlInteger;
  429. }
  431. SqlBigint
  432. SqlField::sqlBigint() const
  433. {
  434.     if (sqlSpec().store() == SqlSpec::Reference) {
  435. ctx_assert(u_data.m_sqlField != 0);
  436. return u_data.m_sqlField->sqlBigint();
  437.     }
  438.     const SqlType& sqlType = sqlSpec().sqlType();
  439.     ctx_assert(sqlType.type() == SqlType::Bigint);
  440.     return u_data.m_sqlBigint;
  441. }
  443. SqlReal
  444. SqlField::sqlReal() const
  445. {
  446.     if (sqlSpec().store() == SqlSpec::Reference) {
  447. ctx_assert(u_data.m_sqlField != 0);
  448. return u_data.m_sqlField->sqlReal();
  449.     }
  450.     const SqlType& sqlType = sqlSpec().sqlType();
  451.     ctx_assert(sqlType.type() == SqlType::Real);
  452.     return u_data.m_sqlReal;
  453. }
  455. SqlDouble
  456. SqlField::sqlDouble() const
  457. {
  458.     if (sqlSpec().store() == SqlSpec::Reference) {
  459. ctx_assert(u_data.m_sqlField != 0);
  460. return u_data.m_sqlField->sqlDouble();
  461.     }
  462.     const SqlType& sqlType = sqlSpec().sqlType();
  463.     ctx_assert(sqlType.type() == SqlType::Double);
  464.     return u_data.m_sqlDouble;
  465. }
  467. SqlDatetime
  468. SqlField::sqlDatetime() const
  469. {
  470.     if (sqlSpec().store() == SqlSpec::Reference) {
  471. ctx_assert(u_data.m_sqlField != 0);
  472. return u_data.m_sqlField->sqlDatetime();
  473.     }
  474.     const SqlType& sqlType = sqlSpec().sqlType();
  475.     ctx_assert(sqlType.type() == SqlType::Datetime);
  476.     return u_data.m_sqlDatetime;
  477. }
  479. // set
  481. void
  482. SqlField::sqlChar(const SqlChar* value, int length)
  483. {
  484.     const SqlType& sqlType = sqlSpec().sqlType();
  485.     ctx_assert(sqlType.type() == SqlType::Char);
  486.     unsigned n = sqlType.length();
  487.     SqlChar* p = n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  488.     const SqlChar* q = value;
  489.     unsigned m = length == SQL_NTS ? strlen((const char*)q) : length;
  490.     ctx_assert(m <= n);
  491.     for (unsigned i = 0; i < m; i++)
  492. *p++ = *q++;
  493.     for (unsigned i = m; i < n; i++)
  494. *p++ = 0x20; // space
  495.     u_null.m_nullFlag = false;
  496. }
  498. void
  499. SqlField::sqlVarchar(const SqlChar* value, int length)
  500. {
  501. #if NDB_VERSION_MAJOR >= 3
  502.     const SqlType& sqlType = sqlSpec().sqlType();
  503.     ctx_assert(sqlType.type() == SqlType::Varchar);
  504.     unsigned n = sqlType.length();
  505.     SqlChar* p = 2 + n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  506.     const SqlChar* q = value;
  507.     unsigned m = length == SQL_NTS ? strlen((const char*)q) : length;
  508.     ctx_assert(m <= n);
  509.     *p++ = (m >> 8) & 0xff; // big-endian
  510.     *p++ = (m & 0xff);
  511.     for (unsigned i = 0; i < m; i++)
  512. *p++ = *q++;
  513.     for (unsigned i = m; i < n; i++)
  514. *p++ = 0x0; // null
  515.     u_null.m_nullFlag = false;
  516. #else
  517.     const SqlType& sqlType = sqlSpec().sqlType();
  518.     ctx_assert(sqlType.type() == SqlType::Varchar);
  519.     unsigned n = sqlType.length();
  520.     SqlChar* p = n + 2 > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  521.     const SqlChar* q = value;
  522.     unsigned m = length == SQL_NTS ? strlen((const char*)q) : length;
  523.     ctx_assert(m <= n);
  524.     for (unsigned i = 0; i < m; i++)
  525. *p++ = *q++;
  526.     for (unsigned i = m; i < n; i++)
  527. *p++ = 0x0; // null
  528.     *p++ = (m >> 8) & 0xff; // big-endian
  529.     *p++ = (m & 0xff);
  530.     u_null.m_nullFlag = false;
  531. #endif
  532. }
  534. void
  535. SqlField::sqlBinary(const SqlChar* value, int length)
  536. {
  537.     const SqlType& sqlType = sqlSpec().sqlType();
  538.     ctx_assert(sqlType.type() == SqlType::Binary);
  539.     unsigned n = sqlType.length();
  540.     SqlChar* p = n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  541.     const SqlChar* q = value;
  542.     unsigned m = length;
  543.     ctx_assert(m <= n);
  544.     for (unsigned i = 0; i < m; i++)
  545. *p++ = *q++;
  546.     for (unsigned i = m; i < n; i++)
  547. *p++ = 0x0; // null
  548.     u_null.m_nullFlag = false;
  549. }
  551. void
  552. SqlField::sqlVarbinary(const SqlChar* value, int length)
  553. {
  554. #if NDB_VERSION_MAJOR >= 3
  555.     const SqlType& sqlType = sqlSpec().sqlType();
  556.     ctx_assert(sqlType.type() == SqlType::Varbinary);
  557.     unsigned n = sqlType.length();
  558.     SqlChar* p = 2 + n > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  559.     const SqlChar* q = value;
  560.     unsigned m = length;
  561.     ctx_assert(m <= n);
  562.     *p++ = (m >> 8) & 0xff; // big-endian
  563.     *p++ = (m & 0xff);
  564.     for (unsigned i = 0; i < m; i++)
  565. *p++ = *q++;
  566.     for (unsigned i = m; i < n; i++)
  567. *p++ = 0x0; // null
  568.     u_null.m_nullFlag = false;
  569. #else
  570.     const SqlType& sqlType = sqlSpec().sqlType();
  571.     ctx_assert(sqlType.type() == SqlType::Varbinary);
  572.     unsigned n = sqlType.length();
  573.     SqlChar* p = n + 2 > SqlField_CharSmall ? u_data.m_sqlChar : u_data.m_sqlCharSmall;
  574.     const SqlChar* q = value;
  575.     unsigned m = length;
  576.     ctx_assert(m <= n);
  577.     for (unsigned i = 0; i < m; i++)
  578. *p++ = *q++;
  579.     for (unsigned i = m; i < n; i++)
  580. *p++ = 0x0; // null
  581.     *p++ = (m >> 8) & 0xff; // big-endian
  582.     *p++ = (m & 0xff);
  583.     u_null.m_nullFlag = false;
  584. #endif
  585. }
  587. void
  588. SqlField::sqlSmallint(SqlSmallint value)
  589. {
  590.     const SqlType& sqlType = sqlSpec().sqlType();
  591.     ctx_assert(sqlType.type() == SqlType::Smallint);
  592.     u_data.m_sqlSmallint = value;
  593.     u_null.m_nullFlag = false;
  594. }
  596. void
  597. SqlField::sqlInteger(SqlInteger value)
  598. {
  599.     const SqlType& sqlType = sqlSpec().sqlType();
  600.     ctx_assert(sqlType.type() == SqlType::Integer);
  601.     u_data.m_sqlInteger = value;
  602.     u_null.m_nullFlag = false;
  603. }
  605. void
  606. SqlField::sqlBigint(SqlBigint value)
  607. {
  608.     const SqlType& sqlType = sqlSpec().sqlType();
  609.     ctx_assert(sqlType.type() == SqlType::Bigint);
  610.     u_data.m_sqlBigint = value;
  611.     u_null.m_nullFlag = false;
  612. }
  614. void
  615. SqlField::sqlReal(SqlReal value)
  616. {
  617.     const SqlType& sqlType = sqlSpec().sqlType();
  618.     ctx_assert(sqlType.type() == SqlType::Real);
  619.     u_data.m_sqlReal = value;
  620.     u_null.m_nullFlag = false;
  621. }
  623. void
  624. SqlField::sqlDouble(SqlDouble value)
  625. {
  626.     const SqlType& sqlType = sqlSpec().sqlType();
  627.     ctx_assert(sqlType.type() == SqlType::Double);
  628.     u_data.m_sqlDouble = value;
  629.     u_null.m_nullFlag = false;
  630. }
  632. void
  633. SqlField::sqlDatetime(SqlDatetime value)
  634. {
  635.     const SqlType& sqlType = sqlSpec().sqlType();
  636.     ctx_assert(sqlType.type() == SqlType::Datetime);
  637.     u_data.m_sqlDatetime = value;
  638.     u_null.m_nullFlag = false;
  639. }
  641. // get and and set null
  643. bool
  644. SqlField::sqlNull() const
  645. {
  646.     if (sqlSpec().store() == SqlSpec::Reference) {
  647. ctx_assert(u_data.m_sqlField != 0);
  648. return u_data.m_sqlField->sqlNull();
  649.     }
  650.     return u_null.m_nullFlag;
  651. }
  653. void
  654. SqlField::sqlNull(bool value)
  655. {
  656.     u_null.m_nullFlag = value;
  657. }
  659. unsigned
  660. SqlField::trim() const
  661. {
  662.     const SqlType& sqlType = sqlSpec().sqlType();
  663.     unsigned n = 0;
  664.     const SqlChar* s = 0;
  665.     if (sqlType.type() == SqlType::Char) {
  666. n = sqlType.length();
  667. s = sqlChar();
  668.     } else if (sqlType.type() == SqlType::Varchar) {
  669. s = sqlVarchar(&n);
  670.     } else {
  671. ctx_assert(false);
  672. return 0;
  673.     }
  674.     while (n > 0 && s[n - 1] == 0x20)
  675. n--;
  676.     return n;
  677. }
  679. void
  680. SqlField::copy(Ctx& ctx, SqlField& out) const
  681. {
  682.     const SqlField& f1 = *this;
  683.     SqlField& f2 = out;
  684.     const SqlType& t1 = f1.sqlSpec().sqlType();
  685.     const SqlType& t2 = f2.sqlSpec().sqlType();
  686.     ctx_assert(t1.type() == t2.type());
  687.     if (f1.sqlNull()) {
  688. f2.sqlNull(true);
  689. return;
  690.     }
  691.     if (t1.type() == SqlType::Char) {
  692. f2.sqlChar(f1.sqlChar(), t1.length());
  693. return;
  694.     }
  695.     if (t1.type() == SqlType::Varchar) {
  696. unsigned length;
  697. const SqlChar* s1 = f1.sqlVarchar(&length);
  698. f2.sqlVarchar(s1, length);
  699. return;
  700.     }
  701.     if (t1.type() == SqlType::Binary) {
  702. f2.sqlBinary(f1.sqlBinary(), t1.length());
  703. return;
  704.     }
  705.     if (t1.type() == SqlType::Varbinary) {
  706. unsigned length;
  707. const SqlChar* s1 = f1.sqlVarbinary(&length);
  708. f2.sqlVarbinary(s1, length);
  709. return;
  710.     }
  711.     if (t1.type() == SqlType::Smallint) {
  712. f2.sqlSmallint(f1.sqlSmallint());
  713. return;
  714.     }
  715.     if (t1.type() == SqlType::Integer) {
  716. f2.sqlInteger(f1.sqlInteger());
  717. return;
  718.     }
  719.     if (t1.type() == SqlType::Bigint) {
  720. f2.sqlBigint(f1.sqlBigint());
  721. return;
  722.     }
  723.     if (t1.type() == SqlType::Real) {
  724. f2.sqlReal(f1.sqlReal());
  725. return;
  726.     }
  727.     if (t1.type() == SqlType::Double) {
  728. f2.sqlDouble(f1.sqlDouble());
  729. return;
  730.     }
  731.     if (t1.type() == SqlType::Datetime) {
  732. f2.sqlDatetime(f1.sqlDatetime());
  733. return;
  734.     }
  735.     ctx_assert(false);
  736. }
  738. bool
  739. SqlField::cast(Ctx& ctx, SqlField& out) const
  740. {
  741.     const SqlField& f1 = *this;
  742.     SqlField& f2 = out;
  743.     if (f1.sqlNull()) {
  744. f2.sqlNull(true);
  745. return true;
  746.     }
  747.     const SqlType& t1 = f1.sqlSpec().sqlType();
  748.     const SqlType& t2 = f2.sqlSpec().sqlType();
  749.     if (t1.type() == SqlType::Char) {
  750. if (t2.type() == SqlType::Char) {
  751.     unsigned n1 = f1.trim();
  752.     if (n1 > t2.length())
  753. return false;
  754.     f2.sqlChar(f1.sqlChar(), n1);
  755.     return true;
  756. }
  757. if (t2.type() == SqlType::Varchar) {
  758.     unsigned n1 = t1.length();
  759.     if (n1 > t2.length())
  760. return false;
  761.     f2.sqlVarchar(f1.sqlChar(), n1);
  762.     return true;
  763. }
  764. if (t2.type() == SqlType::Binary) {
  765.     unsigned n1 = t1.length();
  766.     if (n1 > t2.length())
  767. return false;
  768.     f2.sqlBinary(f1.sqlChar(), n1);
  769.     return true;
  770. }
  771. if (t2.type() == SqlType::Varbinary) {
  772.     unsigned n1 = t1.length();
  773.     if (n1 > t2.length())
  774. return false;
  775.     f2.sqlVarbinary(f1.sqlChar(), n1);
  776.     return true;
  777. }
  778. ctx_assert(false);
  779. return false;
  780.     }
  781.     if (t1.type() == SqlType::Varchar) {
  782. if (t2.type() == SqlType::Char) {
  783.     unsigned n1 = f1.trim();
  784.     if (n1 > t2.length())
  785. return false;
  786.     f2.sqlChar(f1.sqlVarchar(0), n1);
  787.     return true;
  788. }
  789. if (t2.type() == SqlType::Varchar) {
  790.     unsigned n1 = f1.trim();
  791.     if (n1 > t2.length())
  792. return false;
  793.     f2.sqlVarchar(f1.sqlVarchar(0), n1);
  794.     return true;
  795. }
  796. if (t2.type() == SqlType::Binary) {
  797.     unsigned n1 = t1.length();
  798.     if (n1 > t2.length())
  799. return false;
  800.     f2.sqlBinary(f1.sqlVarchar(0), n1);
  801.     return true;
  802. }
  803. if (t2.type() == SqlType::Varbinary) {
  804.     unsigned n1 = t1.length();
  805.     if (n1 > t2.length())
  806. return false;
  807.     f2.sqlVarbinary(f1.sqlVarchar(0), n1);
  808.     return true;
  809. }
  810. ctx_assert(false);
  811. return false;
  812.     }
  813.     if (t1.type() == SqlType::Binary) {
  814. if (t2.type() == SqlType::Binary) {
  815.     unsigned n1 = t1.length();
  816.     if (n1 > t2.length())
  817. return false;
  818.     f2.sqlBinary(f1.sqlBinary(), n1);
  819.     return true;
  820. }
  821. if (t2.type() == SqlType::Varbinary) {
  822.     unsigned n1 = t1.length();
  823.     if (n1 > t2.length())
  824. return false;
  825.     f2.sqlVarbinary(f1.sqlBinary(), n1);
  826.     return true;
  827. }
  828. ctx_assert(false);
  829. return false;
  830.     }
  831.     if (t1.type() == SqlType::Varbinary) {
  832. if (t2.type() == SqlType::Binary) {
  833.     unsigned n1 = t1.length();
  834.     if (n1 > t2.length())
  835. return false;
  836.     f2.sqlBinary(f1.sqlVarbinary(0), n1);
  837.     return true;
  838. }
  839. if (t2.type() == SqlType::Varbinary) {
  840.     unsigned n1 = t1.length();
  841.     if (n1 > t2.length())
  842. return false;
  843.     f2.sqlVarbinary(f1.sqlVarbinary(0), n1);
  844.     return true;
  845. }
  846. ctx_assert(false);
  847. return false;
  848.     }
  849.     if (t1.type() == SqlType::Smallint) {
  850. if (! t2.unSigned()) {
  851.     SqlSmallint x1 = f1.sqlSmallint();
  852.     if (t2.type() == SqlType::Smallint) {
  853. f2.sqlSmallint(x1);
  854. return true;
  855.     }
  856.     if (t2.type() == SqlType::Integer) {
  857. SqlInteger x2 = static_cast<SqlInteger>(x1);
  858. f2.sqlInteger(x2);
  859. return true;
  860.     }
  861.     if (t2.type() == SqlType::Bigint) {
  862. SqlBigint x2 = static_cast<SqlBigint>(x1);
  863. f2.sqlBigint(x2);
  864. return true;
  865.     }
  866.     if (t2.type() == SqlType::Real) {
  867. SqlReal x2 = static_cast<SqlReal>(x1);
  868. f2.sqlReal(x2);
  869. return true;
  870.     }
  871.     if (t2.type() == SqlType::Double) {
  872. SqlDouble x2 = static_cast<SqlDouble>(x1);
  873. f2.sqlDouble(x2);
  874. return true;
  875.     }
  876. } else {
  877.     SqlUsmallint x1 = f1.sqlSmallint();
  878.     if (t2.type() == SqlType::Smallint) {
  879. f2.sqlSmallint(x1);
  880. return true;
  881.     }
  882.     if (t2.type() == SqlType::Integer) {
  883. SqlUinteger x2 = static_cast<SqlUinteger>(x1);
  884. f2.sqlInteger(x2);
  885. return true;
  886.     }
  887.     if (t2.type() == SqlType::Bigint) {
  888. SqlUbigint x2 = static_cast<SqlUbigint>(x1);
  889. f2.sqlBigint(x2);
  890. return true;
  891.     }
  892. }
  893. ctx_assert(false);
  894. return false;
  895.     }
  896.     if (t1.type() == SqlType::Integer) {
  897. if (! t2.unSigned()) {
  898.     SqlInteger x1 = f1.sqlInteger();
  899.     if (t2.type() == SqlType::Smallint) {
  900. SqlSmallint x2 = static_cast<SqlSmallint>(x1);
  901. if (x1 != static_cast<SqlInteger>(x2))
  902.     return false;
  903. f2.sqlSmallint(x2);
  904. return true;
  905.     }
  906.     if (t2.type() == SqlType::Integer) {
  907. f2.sqlInteger(x1);
  908. return true;
  909.     }
  910.     if (t2.type() == SqlType::Bigint) {
  911. SqlBigint x2 = static_cast<SqlBigint>(x1);
  912. f2.sqlBigint(x2);
  913. return true;
  914.     }
  915.     if (t2.type() == SqlType::Real) {
  916. SqlReal x2 = static_cast<SqlReal>(x1);
  917. f2.sqlReal(x2);
  918. return true;
  919.     }
  920.     if (t2.type() == SqlType::Double) {
  921. SqlDouble x2 = static_cast<SqlDouble>(x1);
  922. f2.sqlDouble(x2);
  923. return true;
  924.     }
  925. } else {
  926.     SqlUinteger x1 = f1.sqlInteger();
  927.     if (t2.type() == SqlType::Smallint) {
  928. SqlUsmallint x2 = static_cast<SqlUsmallint>(x1);
  929. if (x1 != static_cast<SqlUinteger>(x2))
  930.     return false;
  931. f2.sqlSmallint(x2);
  932. return true;
  933.     }
  934.     if (t2.type() == SqlType::Integer) {
  935. f2.sqlInteger(x1);
  936. return true;
  937.     }
  938.     if (t2.type() == SqlType::Bigint) {
  939. SqlUbigint x2 = static_cast<SqlUbigint>(x1);
  940. f2.sqlBigint(x2);
  941. return true;
  942.     }
  943. }
  944. ctx_assert(false);
  945. return false;
  946.     }
  947.     if (t1.type() == SqlType::Bigint) {
  948. if (! t2.unSigned()) {
  949.     SqlBigint x1 = f1.sqlBigint();
  950.     if (t2.type() == SqlType::Smallint) {
  951. SqlSmallint x2 = static_cast<SqlSmallint>(x1);
  952. if (x1 != static_cast<SqlBigint>(x2))
  953.     return false;
  954. f2.sqlSmallint(x2);
  955. return true;
  956.     }
  957.     if (t2.type() == SqlType::Integer) {
  958. SqlInteger x2 = static_cast<SqlInteger>(x1);
  959. if (x1 != static_cast<SqlBigint>(x2))
  960.     return false;
  961. f2.sqlInteger(x2);
  962. return true;
  963.     }
  964.     if (t2.type() == SqlType::Bigint) {
  965. f2.sqlBigint(x1);
  966. return true;
  967.     }
  968.     if (t2.type() == SqlType::Real) {
  969. SqlReal x2 = static_cast<SqlReal>(x1);
  970. f2.sqlReal(x2);
  971. return true;
  972.     }
  973.     if (t2.type() == SqlType::Double) {
  974. SqlDouble x2 = static_cast<SqlDouble>(x1);
  975. f2.sqlDouble(x2);
  976. return true;
  977.     }
  978. } else {
  979.     SqlUbigint x1 = f1.sqlBigint();
  980.     if (t2.type() == SqlType::Smallint) {
  981. SqlUsmallint x2 = static_cast<SqlUsmallint>(x1);
  982. if (x1 != static_cast<SqlUbigint>(x2))
  983.     return false;
  984. f2.sqlSmallint(x2);
  985. return true;
  986.     }
  987.     if (t2.type() == SqlType::Integer) {
  988. SqlUinteger x2 = static_cast<SqlUinteger>(x1);
  989. if (x1 != static_cast<SqlUbigint>(x2))
  990.     return false;
  991. f2.sqlInteger(x2);
  992. return true;
  993.     }
  994.     if (t2.type() == SqlType::Bigint) {
  995. f2.sqlBigint(x1);
  996. return true;
  997.     }
  998. }
  999. ctx_assert(false);
  1000. return false;
  1001.     }
  1002.     if (t1.type() == SqlType::Real) {
  1003. SqlReal x1 = f1.sqlReal();
  1004. int off = 0;
  1005. if (x1 > 0.0 && x1 - floor(x1) >= 0.5)
  1006.     off = 1;
  1007. if (x1 < 0.0 && x1 - floor(x1) <= 0.5)
  1008.     off = -1;
  1009. bool b = (x1 - floor(x1) < 0.5);
  1010. if (t2.type() == SqlType::Smallint) {
  1011.     SqlSmallint x2 = static_cast<SqlSmallint>(x1) + off;
  1012.     if (fabs(x1 - static_cast<SqlReal>(x2)) >= 1.0)
  1013. return false;
  1014.     f2.sqlSmallint(x2);
  1015.     return true;
  1016. }
  1017. if (t2.type() == SqlType::Integer) {
  1018.     SqlInteger x2 = static_cast<SqlInteger>(x1) + off;
  1019.     if (fabs(x1 - static_cast<SqlReal>(x2)) >= 1.0)
  1020. return false;
  1021.     f2.sqlInteger(x2);
  1022.     return true;
  1023. }
  1024. if (t2.type() == SqlType::Bigint) {
  1025.     SqlBigint x2 = static_cast<SqlBigint>(x1) + off;
  1026.     if (fabs(x1 - static_cast<SqlReal>(x2)) >= 1.0)
  1027. return false;
  1028.     f2.sqlBigint(x2);
  1029.     return true;
  1030. }
  1031. if (t2.type() == SqlType::Real) {
  1032.     f2.sqlReal(x1);
  1033.     return true;
  1034. }
  1035. if (t2.type() == SqlType::Double) {
  1036.     SqlDouble x2 = static_cast<SqlDouble>(x1);
  1037.     f2.sqlDouble(x2);
  1038.     return true;
  1039. }
  1040. ctx_assert(false);
  1041. return false;
  1042.     }
  1043.     if (t1.type() == SqlType::Double) {
  1044. SqlDouble x1 = f1.sqlDouble();
  1045. int off = 0;
  1046. if (x1 > 0.0 && x1 - floor(x1) >= 0.5)
  1047.     off = 1;
  1048. if (x1 < 0.0 && x1 - floor(x1) <= 0.5)
  1049.     off = -1;
  1050. bool b = (x1 - floor(x1) < 0.5);
  1051. if (t2.type() == SqlType::Smallint) {
  1052.     SqlSmallint x2 = static_cast<SqlSmallint>(x1) + off;
  1053.     if (fabs(x1 - static_cast<SqlDouble>(x2)) >= 1.0)
  1054. return false;
  1055.     f2.sqlSmallint(x2);
  1056.     return true;
  1057. }
  1058. if (t2.type() == SqlType::Integer) {
  1059.     SqlInteger x2 = static_cast<SqlInteger>(x1) + off;
  1060.     if (fabs(x1 - static_cast<SqlDouble>(x2)) >= 1.0)
  1061. return false;
  1062.     f2.sqlInteger(x2);
  1063.     return true;
  1064. }
  1065. if (t2.type() == SqlType::Bigint) {
  1066.     SqlBigint x2 = static_cast<SqlBigint>(x1) + off;
  1067.     if (fabs(x1 - static_cast<SqlDouble>(x2)) >= 1.0)
  1068. return false;
  1069.     f2.sqlBigint(x2);
  1070.     return true;
  1071. }
  1072. if (t2.type() == SqlType::Real) {
  1073.     SqlReal x2 = static_cast<SqlReal>(x1);
  1074.     if (fabs(x1 - static_cast<SqlDouble>(x2)) >= 1.0) // XXX
  1075. return false;
  1076.     f2.sqlReal(x1);
  1077.     return true;
  1078. }
  1079. if (t2.type() == SqlType::Double) {
  1080.     f2.sqlDouble(x1);
  1081.     return true;
  1082. }
  1083. ctx_assert(false);
  1084. return false;
  1085.     }
  1086.     ctx_assert(false);
  1087.     return false;
  1088. }
  1090. bool
  1091. SqlField::less(const SqlField& sqlField) const
  1092. {
  1093.     const SqlField& f1 = *this;
  1094.     const SqlField& f2 = sqlField;
  1095.     const SqlType& t1 = f1.sqlSpec().sqlType();
  1096.     const SqlType& t2 = f2.sqlSpec().sqlType();
  1097.     ctx_assert(t1.type() == t2.type());
  1098.     if (t1.type() == SqlType::Char) {
  1099. const SqlChar* s1 = f1.sqlChar();
  1100. const SqlChar* s2 = f2.sqlChar();
  1101. unsigned n1 = t1.length();
  1102. unsigned n2 = t2.length();
  1103. SqlChar c1 = 0;
  1104. SqlChar c2 = 0;
  1105. unsigned i = 0;
  1106. while (i < n1 || i < n2) {
  1107.     c1 = i < n1 ? s1[i] : 0x20;
  1108.     c2 = i < n2 ? s2[i] : 0x20;
  1109.     if (c1 != c2)
  1110. break;
  1111.     i++;
  1112. }
  1113. return (c1 < c2);
  1114.     }
  1115.     if (t1.type() == SqlType::Varchar) {
  1116. unsigned n1, n2;
  1117. const SqlChar* s1 = f1.sqlVarchar(&n1);
  1118. const SqlChar* s2 = f2.sqlVarchar(&n2);
  1119. SqlChar c1 = 0;
  1120. SqlChar c2 = 0;
  1121. unsigned i = 0;
  1122. while (i < n1 || i < n2) {
  1123.     c1 = i < n1 ? s1[i] : 0x0;
  1124.     c2 = i < n2 ? s2[i] : 0x0;
  1125.     if (c1 != c2)
  1126. break;
  1127.     i++;
  1128. }
  1129. return (c1 < c2);
  1130.     }
  1131.     if (t1.type() == SqlType::Smallint) {
  1132. ctx_assert(t1.unSigned() == t2.unSigned());
  1133. if (! t1.unSigned()) {
  1134.     SqlSmallint x1 = f1.sqlSmallint();
  1135.     SqlSmallint x2 = f2.sqlSmallint();
  1136.     return (x1 < x2);
  1137. } else {
  1138.     SqlUsmallint x1 = f1.sqlSmallint();
  1139.     SqlUsmallint x2 = f2.sqlSmallint();
  1140.     return (x1 < x2);
  1141. }
  1142.     }
  1143.     if (t1.type() == SqlType::Integer) {
  1144. ctx_assert(t1.unSigned() == t2.unSigned());
  1145. if (! t1.unSigned()) {
  1146.     SqlInteger x1 = f1.sqlInteger();
  1147.     SqlInteger x2 = f2.sqlInteger();
  1148.     return (x1 < x2);
  1149. } else {
  1150.     SqlUinteger x1 = f1.sqlInteger();
  1151.     SqlUinteger x2 = f2.sqlInteger();
  1152.     return (x1 < x2);
  1153. }
  1154.     }
  1155.     if (t1.type() == SqlType::Bigint) {
  1156. ctx_assert(t1.unSigned() == t2.unSigned());
  1157. if (! t1.unSigned()) {
  1158.     SqlBigint x1 = f1.sqlBigint();
  1159.     SqlBigint x2 = f2.sqlBigint();
  1160.     return (x1 < x2);
  1161. } else {
  1162.     SqlUbigint x1 = f1.sqlBigint();
  1163.     SqlUbigint x2 = f2.sqlBigint();
  1164.     return (x1 < x2);
  1165. }
  1166.     }
  1167.     if (t1.type() == SqlType::Real) {
  1168. SqlReal x1 = f1.sqlReal();
  1169. SqlReal x2 = f2.sqlReal();
  1170. return (x1 < x2);
  1171.     }
  1172.     if (t1.type() == SqlType::Double) {
  1173. SqlDouble x1 = f1.sqlDouble();
  1174. SqlDouble x2 = f2.sqlDouble();
  1175. return (x1 < x2);
  1176.     }
  1177.     if (t1.type() == SqlType::Datetime) {
  1178. SqlDatetime x1 = f1.sqlDatetime();
  1179. SqlDatetime x2 = f2.sqlDatetime();
  1180. return x1.less(x2);
  1181.     }
  1182.     ctx_assert(false);
  1183. }
  1185. // copy from external
  1187. static bool
  1188. copyin_char_char(Ctx& ctx, char* value, unsigned n, const char* ptr, const SQLINTEGER* ind, int* off, SqlChar* addr, int fieldId)
  1189. {
  1190.     if (off != 0 && *off >= 0) {
  1191. if ((unsigned)*off > n) {
  1192.     ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, (unsigned)*off, n);
  1193.     return false;
  1194. }
  1195. value += *off;
  1196. n -= *off;
  1197.     }
  1198.     unsigned m;
  1199.     if (ind == 0 || *ind == SQL_NTS)
  1200. m = strlen(ptr);
  1201.     else
  1202. m = *ind;
  1203.     if (m > n) {
  1204. ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, m, n);
  1205. return false;
  1206.     }
  1207.     for (unsigned i = 0; i < m; i++)
  1208. value[i] = ptr[i];
  1209.     if (off != 0 && *off >= 0)
  1210. *off += m;
  1211.     for (unsigned i = m; i < n; i++)
  1212. value[i] = addr == 0 ? 0x20 : 0x0;
  1213.     if (addr != 0) {
  1214. if (off != 0 && *off >= 0)
  1215.     m = *off;
  1216. addr[0] = (m >> 8) & 0xff;
  1217. addr[1] = (m & 0xff);
  1218.     }
  1219.     return true;
  1220. }
  1222. static bool
  1223. copyin_binary_binary(Ctx& ctx, char* value, unsigned n, const char* ptr, const SQLINTEGER* ind, int* off, SqlChar* addr, int fieldId)
  1224. {
  1225.     if (off != 0 && *off >= 0) {
  1226. if ((unsigned)*off > n) {
  1227.     ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, (unsigned)*off, n);
  1228.     return false;
  1229. }
  1230. value += *off;
  1231. n -= *off;
  1232.     }
  1233.     if (ind == 0) {
  1234. ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d missing length", fieldId);
  1235. return false;
  1236.     }
  1237.     if (*ind < 0) {
  1238. ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d invalid length %d", fieldId, (int)*ind);
  1239. return false;
  1240.     }
  1241.     unsigned m;
  1242.     m = *ind;
  1243.     if (m > n) {
  1244. ctx.pushStatus(Sqlstate::_22001, Error::Gen, "input parameter %d truncated (%u > %u)", fieldId, m, n);
  1245. return false;
  1246.     }
  1247.     for (unsigned i = 0; i < m; i++)
  1248. value[i] = ptr[i];
  1249.     if (off != 0 && *off >= 0)
  1250. *off += m;
  1251.     for (unsigned i = m; i < n; i++)
  1252. value[i] = addr == 0 ? 0x0 : 0x0; // just null
  1253.     if (addr != 0) {
  1254. if (off != 0 && *off >= 0)
  1255.     m = *off;
  1256. addr[0] = (m >> 8) & 0xff;
  1257. addr[1] = (m & 0xff);
  1258.     }
  1259.     return true;
  1260. }
  1262. static bool
  1263. copyin_signed_char(Ctx& ctx, SqlBigint* value, const char* ptr, int fieldId)
  1264. {
  1265.     errno = 0;
  1266.     char* endptr = 0;
  1267.     SqlBigint x = strtoll(ptr, &endptr, 10);
  1268.     if (endptr == 0 || *endptr != 0) {
  1269.         errno = 0;
  1270.         endptr = 0;
  1271.         double y = strtod(ptr, &endptr);
  1272.         if (endptr == 0 || *endptr != 0) {
  1273.             ctx.pushStatus(Sqlstate::_22005, Error::Gen, "input parameter %d value %s not numeric", fieldId, ptr);
  1274.             return false;
  1275.         } else if (errno != 0) {
  1276.             ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr);
  1277.             return false;
  1278.         }
  1279.         // XXX should handle 123.000
  1280.         ctx.pushStatus(Sqlstate::_01004, Error::Gen, "input parameter %d value %s truncated", fieldId, ptr);
  1281.         x = static_cast<SqlBigint>(y);
  1282.     } else if (errno != 0) {
  1283.         ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr);
  1284.         return false;
  1285.     }
  1286.     *value = x;
  1287.     return true;
  1288. }
  1290. static bool
  1291. copyin_double_char(Ctx& ctx, SqlDouble* value, const char* ptr, int fieldId)
  1292. {
  1293.     errno = 0;
  1294.     char* endptr = 0;
  1295.     double x = strtod(ptr, &endptr);
  1296.     if (endptr == 0 || *endptr != 0) {
  1297.         ctx.pushStatus(Sqlstate::_22005, Error::Gen, "input parameter %d value %s not numeric", fieldId, ptr);
  1298.         return false;
  1299.     } else if (errno != 0) {
  1300.         ctx.pushStatus(Sqlstate::_22003, Error::Gen, "input parameter %d value %s overflow", fieldId, ptr);
  1301.         return false;
  1302.     }
  1303.     *value = x;
  1304.     return true;
  1305. }
  1307. void
  1308. SqlField::copyin(Ctx& ctx, ExtField& extField)
  1309. {
  1310.     ctx_assert(extField.extSpec().extType().type() != ExtType::Unbound);
  1311.     ctx_assert(sqlSpec().store() == SqlSpec::Physical);
  1312.     SQLINTEGER* indPtr = extField.m_indPtr;
  1313.     const int fieldId = extField.fieldId();
  1314.     if (indPtr != 0 && *indPtr == SQL_NULL_DATA) {
  1315. sqlNull(true);
  1316. return;
  1317.     }
  1318.     const SqlType& sqlType = sqlSpec().sqlType();
  1319.     const ExtType& extType = extField.extSpec().extType();
  1320.     if (extField.m_pos > 0) {
  1321. if (sqlType.type() == SqlType::Char && extType.type() == ExtType::Char)
  1322.     ;
  1323. else if (sqlType.type() == SqlType::Varchar && extType.type() == ExtType::Char)
  1324.     ;
  1325. else {
  1326.     char buf[40];
  1327.     sqlType.print(buf, sizeof(buf));
  1328.     ctx.pushStatus(Sqlstate::_HY019, Error::Gen, "cannot send %s data in pieces", buf);
  1329.     return;
  1330. }
  1331.     }
  1332.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  1333. unsigned length = 0;
  1334. char* value = 0;
  1335. SqlChar* laddr = 0; // Varchar length address
  1336. if (sqlType.type() == SqlType::Char) {
  1337.     length = sqlType.length();
  1338.     if (length > SqlField_CharSmall)
  1339. value = reinterpret_cast<char *>(u_data.m_sqlChar);
  1340.     else
  1341. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall);
  1342.     laddr = 0;
  1343. } else {
  1344. #if NDB_VERSION_MAJOR >= 3
  1345.     length = sqlType.length();
  1346.     if (2 + length > SqlField_CharSmall)
  1347. value = reinterpret_cast<char *>(u_data.m_sqlChar + 2);
  1348.     else
  1349. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall + 2);
  1350.     laddr = (SqlChar*)value - 2;
  1351. #else
  1352.     length = sqlType.length();
  1353.     if (length + 2 > SqlField_CharSmall)
  1354. value = reinterpret_cast<char *>(u_data.m_sqlChar);
  1355.     else
  1356. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall);
  1357.     laddr = (SqlChar*)value + length;
  1358. #endif
  1359. }
  1360. if (extType.type() == ExtType::Char) {
  1361.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1362.     int* off = 0;
  1363.     if (extField.m_pos >= 0)
  1364. off = &extField.m_pos;
  1365.     if (! copyin_char_char(ctx, value, length, dataPtr, indPtr, off, laddr, fieldId))
  1366. return;
  1367.     sqlNull(false);
  1368.     return;
  1369. }
  1370. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1371.     const short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1372.     char buf[100];
  1373.     sprintf(buf, "%hd", *dataPtr);
  1374.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1375. return;
  1376.     sqlNull(false);
  1377.     if (extField.m_pos >= 0)
  1378. extField.m_pos = 1;
  1379.     return;
  1380. }
  1381. if (extType.type() == ExtType::Ushort) {
  1382.     const unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1383.     char buf[100];
  1384.     sprintf(buf, "%hu", *dataPtr);
  1385.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1386. return;
  1387.     sqlNull(false);
  1388.     if (extField.m_pos >= 0)
  1389. extField.m_pos = 1;
  1390.     return;
  1391. }
  1392. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1393.     const long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1394.     char buf[100];
  1395.     sprintf(buf, "%ld", *dataPtr);
  1396.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1397. return;
  1398.     sqlNull(false);
  1399.     if (extField.m_pos >= 0)
  1400. extField.m_pos = 1;
  1401.     return;
  1402. }
  1403. if (extType.type() == ExtType::Ulong) {
  1404.     const unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1405.     char buf[100];
  1406.     sprintf(buf, "%lu", *dataPtr);
  1407.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1408. return;
  1409.     sqlNull(false);
  1410.     if (extField.m_pos >= 0)
  1411. extField.m_pos = 1;
  1412.     return;
  1413. }
  1414. if (extType.type() == ExtType::Sbigint) {
  1415.     const SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1416.     char buf[100];
  1417.     sprintf(buf, FMT_I64, *dataPtr);
  1418.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1419. return;
  1420.     sqlNull(false);
  1421.     if (extField.m_pos >= 0)
  1422. extField.m_pos = 1;
  1423.     return;
  1424. }
  1425. if (extType.type() == ExtType::Ubigint) {
  1426.     const SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1427.     char buf[100];
  1428.     sprintf(buf, FMT_U64, *dataPtr);
  1429.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1430. return;
  1431.     sqlNull(false);
  1432.     if (extField.m_pos >= 0)
  1433. extField.m_pos = 1;
  1434.     return;
  1435. }
  1436. if (extType.type() == ExtType::Float) {
  1437.     const float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1438.     char buf[100];
  1439.     sprintf(buf, "%.7f", (double)*dataPtr);
  1440.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1441. return;
  1442.     sqlNull(false);
  1443.     if (extField.m_pos >= 0)
  1444. extField.m_pos = 1;
  1445.     return;
  1446. }
  1447. if (extType.type() == ExtType::Double) {
  1448.     const double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1449.     char buf[100];
  1450.     sprintf(buf, "%.14f", *dataPtr);
  1451.     if (! copyin_char_char(ctx, value, length, buf, indPtr, 0, laddr, fieldId))
  1452. return;
  1453.     sqlNull(false);
  1454.     if (extField.m_pos >= 0)
  1455. extField.m_pos = 1;
  1456.     return;
  1457. }
  1458.     }
  1459.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  1460. unsigned length = 0;
  1461. char* value = 0;
  1462. SqlChar* laddr = 0; // Varbinary length address
  1463. if (sqlType.type() == SqlType::Binary) {
  1464.     length = sqlType.length();
  1465.     if (length > SqlField_CharSmall)
  1466. value = reinterpret_cast<char *>(u_data.m_sqlChar);
  1467.     else
  1468. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall);
  1469.     laddr = 0;
  1470. } else {
  1471. #if NDB_VERSION_MAJOR >= 3
  1472.     length = sqlType.length();
  1473.     if (2 + length > SqlField_CharSmall)
  1474. value = reinterpret_cast<char *>(u_data.m_sqlChar + 2);
  1475.     else
  1476. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall + 2);
  1477.     laddr = (SqlChar*)value - 2;
  1478. #else
  1479.     length = sqlType.length();
  1480.     if (length + 2 > SqlField_CharSmall)
  1481. value = reinterpret_cast<char *>(u_data.m_sqlChar);
  1482.     else
  1483. value = reinterpret_cast<char *>(u_data.m_sqlCharSmall);
  1484.     laddr = (SqlChar*)value + length;
  1485. #endif
  1486. }
  1487. if (extType.type() == ExtType::Binary) {
  1488.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1489.     int* off = 0;
  1490.     if (extField.m_pos >= 0)
  1491. off = &extField.m_pos;
  1492.     if (! copyin_binary_binary(ctx, value, length, dataPtr, indPtr, off, laddr, fieldId))
  1493. return;
  1494.     sqlNull(false);
  1495.     return;
  1496. }
  1497.     }
  1498.     if (sqlType.type() == SqlType::Smallint) {
  1499. SqlSmallint value;
  1500. if (extType.type() == ExtType::Char) {
  1501.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1502.     SqlBigint x;
  1503.     if (! copyin_signed_char(ctx, &x, dataPtr, fieldId))
  1504. return;
  1505.     value = x;
  1506.     sqlSmallint(value);
  1507.     if (extField.m_pos >= 0)
  1508. extField.m_pos = 1;
  1509.     return;
  1510. }
  1511. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1512.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1513.     value = *dataPtr;
  1514.     sqlSmallint(value);
  1515.     if (extField.m_pos >= 0)
  1516. extField.m_pos = 1;
  1517.     return;
  1518. }
  1519. if (extType.type() == ExtType::Ushort) {
  1520.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1521.     value = *dataPtr;
  1522.     sqlSmallint(value);
  1523.     if (extField.m_pos >= 0)
  1524. extField.m_pos = 1;
  1525.     return;
  1526. }
  1527. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1528.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1529.     value = *dataPtr;
  1530.     sqlSmallint(value);
  1531.     if (extField.m_pos >= 0)
  1532. extField.m_pos = 1;
  1533.     return;
  1534. }
  1535. if (extType.type() == ExtType::Ulong) {
  1536.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1537.     value = *dataPtr;
  1538.     sqlSmallint(value);
  1539.     if (extField.m_pos >= 0)
  1540. extField.m_pos = 1;
  1541.     return;
  1542. }
  1543. if (extType.type() == ExtType::Sbigint) {
  1544.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1545.     value = *dataPtr;
  1546.     sqlSmallint(value);
  1547.     if (extField.m_pos >= 0)
  1548. extField.m_pos = 1;
  1549.     return;
  1550. }
  1551. if (extType.type() == ExtType::Ubigint) {
  1552.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1553.     value = *dataPtr;
  1554.     sqlSmallint(value);
  1555.     if (extField.m_pos >= 0)
  1556. extField.m_pos = 1;
  1557.     return;
  1558. }
  1559. if (extType.type() == ExtType::Float) {
  1560.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1561.     value = (SqlSmallint)*dataPtr;
  1562.     sqlSmallint(value);
  1563.     if (extField.m_pos >= 0)
  1564. extField.m_pos = 1;
  1565.     return;
  1566. }
  1567. if (extType.type() == ExtType::Double) {
  1568.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1569.     value = (SqlSmallint)*dataPtr;
  1570.     sqlSmallint(value);
  1571.     if (extField.m_pos >= 0)
  1572. extField.m_pos = 1;
  1573.     return;
  1574. }
  1575.     }
  1576.     if (sqlType.type() == SqlType::Integer) {
  1577. SqlInteger value;
  1578. if (extType.type() == ExtType::Char) {
  1579.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1580.     SqlBigint x;
  1581.     if (! copyin_signed_char(ctx, &x, dataPtr, fieldId))
  1582. return;
  1583.     value = x;
  1584.     sqlInteger(value);
  1585.     if (extField.m_pos >= 0)
  1586. extField.m_pos = 1;
  1587.     return;
  1588. }
  1589. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1590.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1591.     value = *dataPtr;
  1592.     sqlInteger(value);
  1593.     if (extField.m_pos >= 0)
  1594. extField.m_pos = 1;
  1595.     return;
  1596. }
  1597. if (extType.type() == ExtType::Ushort) {
  1598.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1599.     value = *dataPtr;
  1600.     sqlInteger(value);
  1601.     if (extField.m_pos >= 0)
  1602. extField.m_pos = 1;
  1603.     return;
  1604. }
  1605. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1606.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1607.     value = *dataPtr;
  1608.     sqlInteger(value);
  1609.     if (extField.m_pos >= 0)
  1610. extField.m_pos = 1;
  1611.     return;
  1612. }
  1613. if (extType.type() == ExtType::Ulong) {
  1614.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1615.     value = *dataPtr;
  1616.     sqlInteger(value);
  1617.     if (extField.m_pos >= 0)
  1618. extField.m_pos = 1;
  1619.     return;
  1620. }
  1621. if (extType.type() == ExtType::Sbigint) {
  1622.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1623.     value = *dataPtr;
  1624.     sqlInteger(value);
  1625.     if (extField.m_pos >= 0)
  1626. extField.m_pos = 1;
  1627.     return;
  1628. }
  1629. if (extType.type() == ExtType::Ubigint) {
  1630.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1631.     value = *dataPtr;
  1632.     sqlInteger(value);
  1633.     if (extField.m_pos >= 0)
  1634. extField.m_pos = 1;
  1635.     return;
  1636. }
  1637. if (extType.type() == ExtType::Float) {
  1638.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1639.     value = (SqlInteger)*dataPtr;
  1640.     sqlInteger(value);
  1641.     if (extField.m_pos >= 0)
  1642. extField.m_pos = 1;
  1643.     return;
  1644. }
  1645. if (extType.type() == ExtType::Double) {
  1646.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1647.     value = (SqlInteger)*dataPtr;
  1648.     sqlInteger(value);
  1649.     if (extField.m_pos >= 0)
  1650. extField.m_pos = 1;
  1651.     return;
  1652. }
  1653.     }
  1654.     if (sqlType.type() == SqlType::Bigint) {
  1655. SqlBigint value;
  1656. if (extType.type() == ExtType::Char) {
  1657.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1658.     SqlBigint x;
  1659.     if (! copyin_signed_char(ctx, &x, dataPtr, fieldId))
  1660. return;
  1661.     value = x;
  1662.     sqlBigint(value);
  1663.     if (extField.m_pos >= 0)
  1664. extField.m_pos = 1;
  1665.     return;
  1666. }
  1667. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1668.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1669.     value = *dataPtr;
  1670.     sqlBigint(value);
  1671.     if (extField.m_pos >= 0)
  1672. extField.m_pos = 1;
  1673.     return;
  1674. }
  1675. if (extType.type() == ExtType::Ushort) {
  1676.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1677.     value = *dataPtr;
  1678.     sqlBigint(value);
  1679.     if (extField.m_pos >= 0)
  1680. extField.m_pos = 1;
  1681.     return;
  1682. }
  1683. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1684.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1685.     value = *dataPtr;
  1686.     sqlBigint(value);
  1687.     if (extField.m_pos >= 0)
  1688. extField.m_pos = 1;
  1689.     return;
  1690. }
  1691. if (extType.type() == ExtType::Ulong) {
  1692.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1693.     value = *dataPtr;
  1694.     sqlBigint(value);
  1695.     if (extField.m_pos >= 0)
  1696. extField.m_pos = 1;
  1697.     return;
  1698. }
  1699. if (extType.type() == ExtType::Sbigint) {
  1700.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1701.     value = *dataPtr;
  1702.     sqlBigint(value);
  1703.     if (extField.m_pos >= 0)
  1704. extField.m_pos = 1;
  1705.     return;
  1706. }
  1707. if (extType.type() == ExtType::Ubigint) {
  1708.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1709.     value = *dataPtr;
  1710.     sqlBigint(value);
  1711.     if (extField.m_pos >= 0)
  1712. extField.m_pos = 1;
  1713.     return;
  1714. }
  1715. if (extType.type() == ExtType::Float) {
  1716.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1717.     value = (SqlBigint)*dataPtr;
  1718.     sqlBigint(value);
  1719.     if (extField.m_pos >= 0)
  1720. extField.m_pos = 1;
  1721.     return;
  1722. }
  1723. if (extType.type() == ExtType::Double) {
  1724.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1725.     value = (SqlBigint)*dataPtr;
  1726.     sqlBigint(value);
  1727.     if (extField.m_pos >= 0)
  1728. extField.m_pos = 1;
  1729.     return;
  1730. }
  1731.     }
  1732.     if (sqlType.type() == SqlType::Real) {
  1733. SqlReal value;
  1734. if (extType.type() == ExtType::Char) {
  1735.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1736.     SqlDouble x;
  1737.     if (! copyin_double_char(ctx, &x, dataPtr, fieldId))
  1738. return;
  1739.     value = x;
  1740.     sqlReal(x);
  1741.     if (extField.m_pos >= 0)
  1742. extField.m_pos = 1;
  1743.     return;
  1744. }
  1745. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1746.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1747.     value = *dataPtr;
  1748.     sqlReal(value);
  1749.     if (extField.m_pos >= 0)
  1750. extField.m_pos = 1;
  1751.     return;
  1752. }
  1753. if (extType.type() == ExtType::Ushort) {
  1754.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1755.     value = *dataPtr;
  1756.     sqlReal(value);
  1757.     if (extField.m_pos >= 0)
  1758. extField.m_pos = 1;
  1759.     return;
  1760. }
  1761. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1762.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1763.     value = *dataPtr;
  1764.     sqlReal(value);
  1765.     if (extField.m_pos >= 0)
  1766. extField.m_pos = 1;
  1767.     return;
  1768. }
  1769. if (extType.type() == ExtType::Ulong) {
  1770.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1771.     value = *dataPtr;
  1772.     sqlReal(value);
  1773.     if (extField.m_pos >= 0)
  1774. extField.m_pos = 1;
  1775.     return;
  1776. }
  1777. if (extType.type() == ExtType::Sbigint) {
  1778.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1779.     value = *dataPtr;
  1780.     sqlReal(value);
  1781.     if (extField.m_pos >= 0)
  1782. extField.m_pos = 1;
  1783.     return;
  1784. }
  1785. if (extType.type() == ExtType::Ubigint) {
  1786.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1787.     value = *dataPtr;
  1788.     sqlReal(value);
  1789.     if (extField.m_pos >= 0)
  1790. extField.m_pos = 1;
  1791.     return;
  1792. }
  1793. if (extType.type() == ExtType::Float) {
  1794.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1795.     value = *dataPtr;
  1796.     sqlReal(value);
  1797.     if (extField.m_pos >= 0)
  1798. extField.m_pos = 1;
  1799.     return;
  1800. }
  1801. if (extType.type() == ExtType::Double) {
  1802.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1803.     value = *dataPtr;
  1804.     sqlReal(value);
  1805.     if (extField.m_pos >= 0)
  1806. extField.m_pos = 1;
  1807.     return;
  1808. }
  1809.     }
  1810.     if (sqlType.type() == SqlType::Double) {
  1811. SqlDouble value;
  1812. if (extType.type() == ExtType::Char) {
  1813.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1814.     SqlDouble x;
  1815.     if (! copyin_double_char(ctx, &x, dataPtr, fieldId))
  1816. return;
  1817.     value = x;
  1818.     sqlDouble(x);
  1819.     if (extField.m_pos >= 0)
  1820. extField.m_pos = 1;
  1821.     return;
  1822. }
  1823. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  1824.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  1825.     value = *dataPtr;
  1826.     sqlDouble(value);
  1827.     if (extField.m_pos >= 0)
  1828. extField.m_pos = 1;
  1829.     return;
  1830. }
  1831. if (extType.type() == ExtType::Ushort) {
  1832.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  1833.     value = *dataPtr;
  1834.     sqlDouble(value);
  1835.     if (extField.m_pos >= 0)
  1836. extField.m_pos = 1;
  1837.     return;
  1838. }
  1839. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  1840.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  1841.     value = *dataPtr;
  1842.     sqlDouble(value);
  1843.     if (extField.m_pos >= 0)
  1844. extField.m_pos = 1;
  1845.     return;
  1846. }
  1847. if (extType.type() == ExtType::Ulong) {
  1848.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  1849.     value = *dataPtr;
  1850.     sqlDouble(value);
  1851.     if (extField.m_pos >= 0)
  1852. extField.m_pos = 1;
  1853.     return;
  1854. }
  1855. if (extType.type() == ExtType::Sbigint) {
  1856.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  1857.     value = *dataPtr;
  1858.     sqlDouble(value);
  1859.     if (extField.m_pos >= 0)
  1860. extField.m_pos = 1;
  1861.     return;
  1862. }
  1863. if (extType.type() == ExtType::Ubigint) {
  1864.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  1865.     value = *dataPtr;
  1866.     sqlDouble(value);
  1867.     if (extField.m_pos >= 0)
  1868. extField.m_pos = 1;
  1869.     return;
  1870. }
  1871. if (extType.type() == ExtType::Float) {
  1872.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  1873.     value = *dataPtr;
  1874.     sqlDouble(value);
  1875.     if (extField.m_pos >= 0)
  1876. extField.m_pos = 1;
  1877.     return;
  1878. }
  1879. if (extType.type() == ExtType::Double) {
  1880.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  1881.     value = *dataPtr;
  1882.     sqlDouble(value);
  1883.     if (extField.m_pos >= 0)
  1884. extField.m_pos = 1;
  1885.     return;
  1886. }
  1887.     }
  1888.     if (sqlType.type() == SqlType::Datetime) {
  1889. SqlDatetime value;
  1890. if (extType.type() == ExtType::Char) {
  1891.     // XXX replace sscanf by manual scan or regex
  1892.     const char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  1893.     int cc = 0;
  1894.     unsigned yy = 0, mm = 0, dd = 0, HH = 0, MM = 0, SS = 0, ff = 0;
  1895.     bool setdate = false;
  1896.     char dummy[10];
  1897.     if (sscanf(dataPtr, "%2d%2u-%2u-%2u %2u:%2u:%2u.%4u%1s", &cc, &yy, &mm, &dd, &HH, &MM, &SS, &ff, dummy) == 8) {
  1898. ;
  1899.     } else if (sscanf(dataPtr, "%2d%2u-%2u-%2u %2u:%2u:%2u%1s", &cc, &yy, &mm, &dd, &HH, &MM, &SS, dummy) == 7) {
  1900. ;
  1901.     } else if (sscanf(dataPtr, "%2d%2u-%2u-%2u%1s", &cc, &yy, &mm, &dd, dummy) == 4) {
  1902. ;
  1903.     } else if (sscanf(dataPtr, "%2u:%2u:%2u.%4u%1s", &HH, &MM, &SS, &ff, dummy) == 4) {
  1904. setdate = true;
  1905.     } else if (sscanf(dataPtr, "%2u:%2u:%2u%1s", &HH, &MM, &SS, dummy) == 3) {
  1906. setdate = true;
  1907.     } else {
  1908. ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp format '%s'", dataPtr);
  1909. return;
  1910.     }
  1911.     if (setdate) {
  1912. time_t clock = time(0);
  1913. struct tm* t = localtime(&clock);
  1914. cc = (1900 + t->tm_year) / 100;
  1915. yy = (1900 + t->tm_year) % 100;
  1916. mm = 1 + t->tm_mon;
  1917. dd = t->tm_mday;
  1918.     }
  1919.     value.cc(cc);
  1920.     value.yy(yy);
  1921.     value.mm(mm);
  1922.     value.dd(dd);
  1923.     value.HH(HH);
  1924.     value.MM(MM);
  1925.     value.SS(SS);
  1926.     value.ff(ff);
  1927.     // XXX write date routines later
  1928.     if (! value.valid()) {
  1929. ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp values '%s'", dataPtr);
  1930. return;
  1931.     }
  1932.     sqlDatetime(value);
  1933.     if (extField.m_pos >= 0)
  1934. extField.m_pos = 1;
  1935.     return;
  1936. }
  1937. if (extType.type() == ExtType::Timestamp) {
  1938.     SQL_TIMESTAMP_STRUCT* dataPtr = static_cast<SQL_TIMESTAMP_STRUCT*>(extField.m_dataPtr);
  1939.     // XXX assume same datatype
  1940.     value.cc(dataPtr->year / 100);
  1941.     value.yy(dataPtr->year / 100);
  1942.     value.mm(dataPtr->month);
  1943.     value.dd(dataPtr->day);
  1944.     value.HH(dataPtr->hour);
  1945.     value.MM(dataPtr->minute);
  1946.     value.SS(dataPtr->second);
  1947.     value.ff(dataPtr->fraction);
  1948.     if (! value.valid()) {
  1949. ctx.pushStatus(Sqlstate::_22008, Error::Gen, "invalid timestamp struct");
  1950. return;
  1951.     }
  1952.     sqlDatetime(value);
  1953.     if (extField.m_pos >= 0)
  1954. extField.m_pos = 1;
  1955.     return;
  1956. }
  1957.     }
  1958.     ctx_assert(false); // SqlType::Null not applicable
  1959. }
  1961. // copy to external
  1963. static bool
  1964. copyout_char_char(Ctx& ctx, const char* value, unsigned n, char* ptr, unsigned len, SQLINTEGER* ind, int* off)
  1965. {
  1966.     unsigned n2 = n;
  1967.     if (off != 0 && *off >= 0) {
  1968. ctx_assert((unsigned)*off <= n2);
  1969. value += *off;
  1970. n2 -= *off;
  1971. if (len < n2 + 1) {
  1972.     ctx.pushStatus(Sqlstate::_01004, Error::Gen, "more data at offset %d, current fetch %u, available %u", *off, len, n2);
  1973.     n2 = len - 1;
  1974. }
  1975.     } else {
  1976. if (len < n + 1) { // room for null byte
  1977.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "char value '%.*s' overflow (%u < %u)", (int)n, value, (unsigned)len, (unsigned)(len + 1));
  1978.     return false;
  1979. }
  1980.     }
  1981.     memcpy(ptr, value, n2);
  1982.     ptr[n2] = 0;
  1983.     if (off != 0 && *off >= 0) {
  1984. if (ind != 0)
  1985.     *ind = n - *off;
  1986. *off += n2;
  1987.     } else {
  1988. if (ind != 0)
  1989.     *ind = n;
  1990.     }
  1991.     return true;
  1992. }
  1994. static bool
  1995. copyout_binary_binary(Ctx& ctx, const char* value, unsigned n, char* ptr, unsigned len, SQLINTEGER* ind, int* off)
  1996. {
  1997.     unsigned n2 = n;
  1998.     if (off != 0 && *off >= 0) {
  1999. ctx_assert((unsigned)*off <= n2);
  2000. value += *off;
  2001. n2 -= *off;
  2002. if (len < n2 + 1) {
  2003.     ctx.pushStatus(Sqlstate::_01004, Error::Gen, "more data at offset %d, current fetch %u, available %u", *off, len, n2);
  2004.     n2 = len - 1;
  2005. }
  2006.     } else {
  2007. if (len < n) { // no room for null byte
  2008.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "binary value '%.*s' overflow (%u < %u)", (int)n, value, (unsigned)len, (unsigned)n);
  2009.     return false;
  2010. }
  2011.     }
  2012.     memcpy(ptr, value, n2);
  2013.     ptr[n2] = 0;
  2014.     if (off != 0 && *off >= 0) {
  2015. if (ind != 0)
  2016.     *ind = n - *off;
  2017. *off += n2;
  2018.     } else {
  2019. if (ind != 0)
  2020.     *ind = n;
  2021.     }
  2022.     return true;
  2023. }
  2025. static bool
  2026. copyout_char_signed(Ctx& ctx, const char* value, unsigned n, long* ptr)
  2027. {
  2028.     while (n > 0 && value[0] == 0x20) {
  2029. value++;
  2030. n--;
  2031.     }
  2032.     char buf[200];
  2033.     if (n >= 200)
  2034. n = 200 - 1;
  2035.     memcpy(buf, value, n);
  2036.     buf[n] = 0;
  2037.     errno = 0;
  2038.     char* endptr = 0;
  2039.     long x = strtol(buf, &endptr, 10);
  2040.     if (endptr == 0 || *endptr != 0) {
  2041. errno = 0;
  2042. endptr = 0;
  2043. double y = strtod(buf, &endptr);
  2044. if (endptr == 0 || *endptr != 0) {
  2045.     ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf);
  2046.     return false;
  2047. } else if (errno != 0) {
  2048.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2049.     return false;
  2050. }
  2051. // XXX should handle 123.000
  2052. ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf);
  2053. x = static_cast<long>(y);
  2054.     } else if (errno != 0) {
  2055. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2056. return false;
  2057.     }
  2058.     *ptr = x;
  2059.     return true;
  2060. }
  2062. static bool
  2063. copyout_char_bigsigned(Ctx& ctx, const char* value, unsigned n, SQLBIGINT* ptr)
  2064. {
  2065.     while (n > 0 && value[0] == 0x20) {
  2066. value++;
  2067. n--;
  2068.     }
  2069.     char buf[200];
  2070.     if (n >= 200)
  2071. n = 200 - 1;
  2072.     memcpy(buf, value, n);
  2073.     buf[n] = 0;
  2074.     errno = 0;
  2075.     char* endptr = 0;
  2076.     SQLBIGINT x = strtoll(buf, &endptr, 10);
  2077.     if (endptr == 0 || *endptr != 0) {
  2078. errno = 0;
  2079. endptr = 0;
  2080. double y = strtod(buf, &endptr);
  2081. if (endptr == 0 || *endptr != 0) {
  2082.     ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf);
  2083.     return false;
  2084. } else if (errno != 0) {
  2085.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2086.     return false;
  2087. }
  2088. // XXX should handle 123.000
  2089. ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf);
  2090. x = static_cast<long>(y);
  2091.     } else if (errno != 0) {
  2092. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2093. return false;
  2094.     }
  2095.     *ptr = x;
  2096.     return true;
  2097. }
  2099. static bool
  2100. copyout_char_unsigned(Ctx& ctx, const char* value, unsigned n, unsigned long* ptr)
  2101. {
  2102.     while (n > 0 && value[0] == 0x20) {
  2103. value++;
  2104. n--;
  2105.     }
  2106.     char buf[200];
  2107.     if (n >= 200)
  2108. n = 200 - 1;
  2109.     memcpy(buf, value, n);
  2110.     buf[n] = 0;
  2111.     errno = 0;
  2112.     char* endptr = 0;
  2113.     unsigned long x = strtoul(buf, &endptr, 10);
  2114.     if (endptr == 0 || *endptr != 0) {
  2115. errno = 0;
  2116. endptr = 0;
  2117. double y = strtod(buf, &endptr);
  2118. if (endptr == 0 || *endptr != 0) {
  2119.     ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf);
  2120.     return false;
  2121. } else if (errno != 0) {
  2122.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2123.     return false;
  2124. }
  2125. // XXX should handle 123.000
  2126. ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf);
  2127. x = static_cast<unsigned long>(y);
  2128.     } else if (errno != 0) {
  2129. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2130. return false;
  2131.     }
  2132.     *ptr = x;
  2133.     return true;
  2134. }
  2136. static bool
  2137. copyout_char_bigunsigned(Ctx& ctx, const char* value, unsigned n, SQLUBIGINT* ptr)
  2138. {
  2139.     while (n > 0 && value[0] == 0x20) {
  2140. value++;
  2141. n--;
  2142.     }
  2143.     char buf[200];
  2144.     if (n >= 200)
  2145. n = 200 - 1;
  2146.     memcpy(buf, value, n);
  2147.     buf[n] = 0;
  2148.     errno = 0;
  2149.     char* endptr = 0;
  2150.     SQLUBIGINT x = strtoull(buf, &endptr, 10);
  2151.     if (endptr == 0 || *endptr != 0) {
  2152. errno = 0;
  2153. endptr = 0;
  2154. double y = strtod(buf, &endptr);
  2155. if (endptr == 0 || *endptr != 0) {
  2156.     ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", buf);
  2157.     return false;
  2158. } else if (errno != 0) {
  2159.     ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2160.     return false;
  2161. }
  2162. // XXX should handle 123.000
  2163. ctx.pushStatus(Sqlstate::_01004, Error::Gen, "value %s truncated", buf);
  2164. x = static_cast<unsigned long>(y);
  2165.     } else if (errno != 0) {
  2166. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2167. return false;
  2168.     }
  2169.     *ptr = x;
  2170.     return true;
  2171. }
  2173. static bool
  2174. copyout_char_double(Ctx& ctx, const char* value, unsigned n, double* ptr)
  2175. {
  2176.     while (n > 0 && value[0] == 0x20) {
  2177. value++;
  2178. n--;
  2179.     }
  2180.     char buf[200];
  2181.     if (n >= 200)
  2182. n = 200 - 1;
  2183.     memcpy(buf, value, n);
  2184.     buf[n] = 0;
  2185.     errno = 0;
  2186.     char* endptr = 0;
  2187.     double x = strtod(value, &endptr);
  2188.     if (endptr == 0 || *endptr != 0) {
  2189. ctx.pushStatus(Sqlstate::_22005, Error::Gen, "value %s not numeric", value);
  2190. return false;
  2191.     } else if (errno != 0) {
  2192. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value);
  2193. return false;
  2194.     }
  2195.     *ptr = x;
  2196.     return true;
  2197. }
  2199. static bool
  2200. copyout_signed_char(Ctx& ctx, Int64 value, char* ptr, int len, SQLINTEGER* ind)
  2201. {
  2202.     char buf[100];
  2203.     sprintf(buf, FMT_I64, value);
  2204.     unsigned n = strlen(buf);
  2205.     if (len <= 0) {
  2206. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len);
  2207. return false;
  2208.     }
  2209.     if ((unsigned)len < n + 1) { // room for null byte
  2210. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2211. return false;
  2212.     }
  2213.     strcpy(ptr, buf);
  2214.     if (ind != 0)
  2215. *ind = n;
  2216.     return true;
  2217. }
  2219. static bool
  2220. copyout_unsigned_char(Ctx& ctx, Uint64 uvalue, char* ptr, int len, SQLINTEGER* ind)
  2221. {
  2222.     char buf[100];
  2223.     sprintf(buf, FMT_U64, uvalue);
  2224.     unsigned n = strlen(buf);
  2225.     if (len <= 0) {
  2226. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len);
  2227. return false;
  2228.     }
  2229.     if ((unsigned)len < n + 1) { // room for null byte
  2230. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2231. return false;
  2232.     }
  2233.     strcpy(ptr, buf);
  2234.     if (ind != 0)
  2235. *ind = n;
  2236.     return true;
  2237. }
  2239. static bool
  2240. copyout_double_char(Ctx& ctx, double value, unsigned prec, char* ptr, int len, SQLINTEGER* ind)
  2241. {
  2242.     char buf[100];
  2243.     sprintf(buf, "%.*f", (int)prec, value);
  2244.     char* p = buf + strlen(buf);
  2245.     while (p > buf + prec)
  2246. *--p = 0;
  2247.     while (p > buf && *(p - 1) == '0')
  2248. *--p = 0;
  2249.     if (p > buf && *(p - 1) == '.') {
  2250. *p++ = '0';
  2251. *p = 0;
  2252.     }
  2253.     unsigned n = strlen(buf);
  2254.     if (len <= 0) {
  2255. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", len);
  2256. return false;
  2257.     }
  2258.     if ((unsigned)len  < n + 1) { // room for null byte
  2259. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", buf);
  2260. return false;
  2261.     }
  2262.     strcpy(ptr, buf);
  2263.     if (ind != 0)
  2264. *ind = n;
  2265.     return true;
  2266. }
  2268. void
  2269. SqlField::copyout(Ctx& ctx, ExtField& extField) const
  2270. {
  2271.     if (extField.extSpec().extType().type() == ExtType::Unbound) {
  2272. return; // output buffer may be unbound
  2273.     }
  2274.     if (sqlSpec().store() == SqlSpec::Reference) {
  2275. ctx_assert(u_data.m_sqlField != 0);
  2276. u_data.m_sqlField->copyout(ctx, extField);
  2277. return;
  2278.     }
  2279.     SQLINTEGER* indPtr = extField.m_indPtr;
  2280.     if (u_null.m_nullFlag) {
  2281. if (extField.m_pos > 0) { // second time from SQLGetData
  2282.     ctx.setCode(SQL_NO_DATA);
  2283.     return;
  2284. }
  2285. if (indPtr == 0) {
  2286.     ctx.pushStatus(Sqlstate::_22002, Error::Gen, "indicator variable required");
  2287.     return;
  2288. }
  2289. *indPtr = SQL_NULL_DATA;
  2290. if (extField.m_pos >= 0)
  2291.     extField.m_pos = 1;
  2292. return;
  2293.     }
  2294.     const SqlType& sqlType = sqlSpec().sqlType();
  2295.     const ExtType& extType = extField.extSpec().extType();
  2296.     if (sqlType.type() == SqlType::Char || sqlType.type() == SqlType::Varchar) {
  2297. unsigned n = 0;
  2298. const char* value = 0;
  2299. if (sqlType.type() == SqlType::Char) {
  2300.     n = sqlType.length();
  2301.     value = reinterpret_cast<const char*>(sqlChar());
  2302. } else {
  2303.     value = reinterpret_cast<const char*>(sqlVarchar(&n));
  2304. }
  2305. if (extType.type() == ExtType::Char) {
  2306.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2307.     if (extField.m_dataLen <= 0) {
  2308. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", (int)extField.m_dataLen);
  2309. return;
  2310.     }
  2311.     int* off = 0;
  2312.     if (extField.m_pos >= 0) {
  2313. off = &extField.m_pos;
  2314. if ((unsigned)*off >= n) {
  2315.     ctx.setCode(SQL_NO_DATA);
  2316.     return;
  2317. }
  2318.     }
  2319.     if (! copyout_char_char(ctx, value, n, dataPtr, extField.m_dataLen, indPtr, off))
  2320. return;
  2321.     return;
  2322. }
  2323. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2324.     if (extField.m_pos > 0) {
  2325. ctx.setCode(SQL_NO_DATA);
  2326. return;
  2327.     }
  2328.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2329.     long x;
  2330.     if (! copyout_char_signed(ctx, value, n, &x))
  2331. return;
  2332.     if (x < SHRT_MIN || x > SHRT_MAX) {
  2333. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value);
  2334. return;
  2335.     }
  2336.     *dataPtr = static_cast<short>(x);
  2337.     if (indPtr != 0)
  2338. *indPtr = sizeof(short);
  2339.     if (extField.m_pos >= 0)
  2340. extField.m_pos = 1;
  2341.     return;
  2342. }
  2343. if (extType.type() == ExtType::Ushort) {
  2344.     if (extField.m_pos > 0) {
  2345. ctx.setCode(SQL_NO_DATA);
  2346. return;
  2347.     }
  2348.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2349.     unsigned long x;
  2350.     if (! copyout_char_unsigned(ctx, value, n, &x))
  2351. return;
  2352.     if (x > USHRT_MAX) {
  2353. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value);
  2354. return;
  2355.     }
  2356.     *dataPtr = static_cast<unsigned short>(x);
  2357.     if (indPtr != 0)
  2358. *indPtr = sizeof(unsigned short);
  2359.     if (extField.m_pos >= 0)
  2360. extField.m_pos = 1;
  2361.     return;
  2362. }
  2363. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2364.     if (extField.m_pos > 0) {
  2365. ctx.setCode(SQL_NO_DATA);
  2366. return;
  2367.     }
  2368.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2369.     if (! copyout_char_signed(ctx, value, n, dataPtr))
  2370. return;
  2371.     if (indPtr != 0)
  2372. *indPtr = sizeof(long);
  2373.     if (extField.m_pos >= 0)
  2374. extField.m_pos = 1;
  2375.     return;
  2376. }
  2377. if (extType.type() == ExtType::Ulong) {
  2378.     if (extField.m_pos > 0) {
  2379. ctx.setCode(SQL_NO_DATA);
  2380. return;
  2381.     }
  2382.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2383.     if (! copyout_char_unsigned(ctx, value, n, dataPtr))
  2384. return;
  2385.     if (indPtr != 0)
  2386. *indPtr = sizeof(unsigned long);
  2387.     if (extField.m_pos >= 0)
  2388. extField.m_pos = 1;
  2389.     return;
  2390. }
  2391. if (extType.type() == ExtType::Sbigint) {
  2392.     if (extField.m_pos > 0) {
  2393. ctx.setCode(SQL_NO_DATA);
  2394. return;
  2395.     }
  2396.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2397.     if (! copyout_char_bigsigned(ctx, value, n, dataPtr))
  2398. return;
  2399.     if (indPtr != 0)
  2400. *indPtr = sizeof(SQLBIGINT);
  2401.     if (extField.m_pos >= 0)
  2402. extField.m_pos = 1;
  2403.     return;
  2404. }
  2405. if (extType.type() == ExtType::Ubigint) {
  2406.     if (extField.m_pos > 0) {
  2407. ctx.setCode(SQL_NO_DATA);
  2408. return;
  2409.     }
  2410.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2411.     if (! copyout_char_bigunsigned(ctx, value, n, dataPtr))
  2412. return;
  2413.     if (indPtr != 0)
  2414. *indPtr = sizeof(SQLUBIGINT);
  2415.     if (extField.m_pos >= 0)
  2416. extField.m_pos = 1;
  2417.     return;
  2418. }
  2419. if (extType.type() == ExtType::Float) {
  2420.     if (extField.m_pos > 0) {
  2421. ctx.setCode(SQL_NO_DATA);
  2422. return;
  2423.     }
  2424.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2425.     double x;
  2426.     if (! copyout_char_double(ctx, value, n, &x))
  2427. return;
  2428.     if (fabs(x) < FLT_MIN || fabs(x) > FLT_MAX) {
  2429. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %s overflow", value);
  2430. return;
  2431.     }
  2432.     *dataPtr = static_cast<float>(x);
  2433.     if (indPtr != 0)
  2434. *indPtr = sizeof(float);
  2435.     if (extField.m_pos >= 0)
  2436. extField.m_pos = 1;
  2437.     return;
  2438. }
  2439. if (extType.type() == ExtType::Double) {
  2440.     if (extField.m_pos > 0) {
  2441. ctx.setCode(SQL_NO_DATA);
  2442. return;
  2443.     }
  2444.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2445.     double x;
  2446.     if (! copyout_char_double(ctx, value, n, &x))
  2447. return;
  2448.     *dataPtr = static_cast<double>(x);
  2449.     if (indPtr != 0)
  2450. *indPtr = sizeof(double);
  2451.     if (extField.m_pos >= 0)
  2452. extField.m_pos = 1;
  2453.     return;
  2454. }
  2455.     }
  2456.     if (sqlType.type() == SqlType::Binary || sqlType.type() == SqlType::Varbinary) {
  2457. unsigned n = 0;
  2458. const char* value = 0;
  2459. if (sqlType.type() == SqlType::Binary) {
  2460.     n = sqlType.length();
  2461.     value = reinterpret_cast<const char*>(sqlBinary());
  2462. } else {
  2463.     value = reinterpret_cast<const char*>(sqlVarbinary(&n));
  2464. }
  2465. if (extType.type() == ExtType::Binary) {
  2466.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2467.     if (extField.m_dataLen <= 0) {
  2468. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid output buffer length %d", (int)extField.m_dataLen);
  2469. return;
  2470.     }
  2471.     int* off = 0;
  2472.     if (extField.m_pos >= 0) {
  2473. off = &extField.m_pos;
  2474. if ((unsigned)*off >= n) {
  2475.     ctx.setCode(SQL_NO_DATA);
  2476.     return;
  2477. }
  2478.     }
  2479.     if (! copyout_binary_binary(ctx, value, n, dataPtr, extField.m_dataLen, indPtr, off))
  2480. return;
  2481.     return;
  2482. }
  2483.     }
  2484.     if (sqlType.type() == SqlType::Smallint) {
  2485. if (extField.m_pos > 0) {
  2486.     ctx.setCode(SQL_NO_DATA);
  2487.     return;
  2488. }
  2489. const SqlSmallint value = sqlSmallint();
  2490. const SqlUsmallint uvalue = value;
  2491. if (extType.type() == ExtType::Char) {
  2492.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2493.     if (! sqlType.unSigned()) {
  2494. if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr))
  2495.     return;
  2496.     } else {
  2497. if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr))
  2498.     return;
  2499.     }
  2500.     if (extField.m_pos >= 0)
  2501. extField.m_pos = 1;
  2502.     return;
  2503. }
  2504. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2505.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2506.     *dataPtr = static_cast<short>(value); // big enough
  2507.     if (indPtr != 0)
  2508. *indPtr = sizeof(short);
  2509.     if (extField.m_pos >= 0)
  2510. extField.m_pos = 1;
  2511.     return;
  2512. }
  2513. if (extType.type() == ExtType::Ushort) {
  2514.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2515.     *dataPtr = static_cast<unsigned short>(uvalue);
  2516.     if (indPtr != 0)
  2517. *indPtr = sizeof(unsigned short);
  2518.     if (extField.m_pos >= 0)
  2519. extField.m_pos = 1;
  2520.     return;
  2521. }
  2522. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2523.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2524.     *dataPtr = static_cast<long>(value); // big enough
  2525.     if (indPtr != 0)
  2526. *indPtr = sizeof(long);
  2527.     if (extField.m_pos >= 0)
  2528. extField.m_pos = 1;
  2529.     return;
  2530. }
  2531. if (extType.type() == ExtType::Ulong) {
  2532.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2533.     *dataPtr = static_cast<unsigned long>(uvalue);
  2534.     if (indPtr != 0)
  2535. *indPtr = sizeof(unsigned long);
  2536.     if (extField.m_pos >= 0)
  2537. extField.m_pos = 1;
  2538.     return;
  2539. }
  2540. if (extType.type() == ExtType::Sbigint) {
  2541.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2542.     *dataPtr = static_cast<SQLBIGINT>(value); // big enough
  2543.     if (indPtr != 0)
  2544. *indPtr = sizeof(SQLBIGINT);
  2545.     if (extField.m_pos >= 0)
  2546. extField.m_pos = 1;
  2547.     return;
  2548. }
  2549. if (extType.type() == ExtType::Ubigint) {
  2550.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2551.     *dataPtr = static_cast<SQLUBIGINT>(uvalue);
  2552.     if (indPtr != 0)
  2553. *indPtr = sizeof(SQLUBIGINT);
  2554.     if (extField.m_pos >= 0)
  2555. extField.m_pos = 1;
  2556.     return;
  2557. }
  2558. if (extType.type() == ExtType::Float) {
  2559.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2560.     *dataPtr = static_cast<float>(value); // big enough
  2561.     if (indPtr != 0)
  2562. *indPtr = sizeof(float);
  2563.     if (extField.m_pos >= 0)
  2564. extField.m_pos = 1;
  2565.     return;
  2566. }
  2567. if (extType.type() == ExtType::Double) {
  2568.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2569.     *dataPtr = static_cast<double>(value); // big enough
  2570.     if (indPtr != 0)
  2571. *indPtr = sizeof(double);
  2572.     if (extField.m_pos >= 0)
  2573. extField.m_pos = 1;
  2574.     return;
  2575. }
  2576.     }
  2577.     if (sqlType.type() == SqlType::Integer) {
  2578. if (extField.m_pos > 0) {
  2579.     ctx.setCode(SQL_NO_DATA);
  2580.     return;
  2581. }
  2582. const SqlInteger value = sqlInteger();
  2583. const SqlUinteger uvalue = value;
  2584. if (extType.type() == ExtType::Char) {
  2585.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2586.     if (! sqlType.unSigned()) {
  2587. if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr))
  2588.     return;
  2589.     } else {
  2590. if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr))
  2591.     return;
  2592.     }
  2593.     if (extField.m_pos >= 0)
  2594. extField.m_pos = 1;
  2595.     return;
  2596. }
  2597. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2598.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2599.     if (value < SHRT_MIN || value > SHRT_MAX) {
  2600. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %d overflow", (int)value);
  2601. return;
  2602.     }
  2603.     *dataPtr = static_cast<short>(value);
  2604.     if (indPtr != 0)
  2605. *indPtr = sizeof(short);
  2606.     if (extField.m_pos >= 0)
  2607. extField.m_pos = 1;
  2608.     return;
  2609. }
  2610. if (extType.type() == ExtType::Ushort) {
  2611.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2612.     if (uvalue > USHRT_MAX) {
  2613. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %u overflow", uvalue);
  2614. return;
  2615.     }
  2616.     *dataPtr = static_cast<unsigned short>(value);
  2617.     if (indPtr != 0)
  2618. *indPtr = sizeof(unsigned short);
  2619.     if (extField.m_pos >= 0)
  2620. extField.m_pos = 1;
  2621.     return;
  2622. }
  2623. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2624.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2625.     *dataPtr = static_cast<long>(value); // big enough
  2626.     if (indPtr != 0)
  2627. *indPtr = sizeof(long);
  2628.     if (extField.m_pos >= 0)
  2629. extField.m_pos = 1;
  2630.     return;
  2631. }
  2632. if (extType.type() == ExtType::Ulong) {
  2633.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2634.     *dataPtr = static_cast<unsigned long>(uvalue);
  2635.     if (indPtr != 0)
  2636. *indPtr = sizeof(unsigned long);
  2637.     if (extField.m_pos >= 0)
  2638. extField.m_pos = 1;
  2639.     return;
  2640. }
  2641. if (extType.type() == ExtType::Sbigint) {
  2642.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2643.     *dataPtr = static_cast<SQLBIGINT>(value); // big enough
  2644.     if (indPtr != 0)
  2645. *indPtr = sizeof(SQLBIGINT);
  2646.     if (extField.m_pos >= 0)
  2647. extField.m_pos = 1;
  2648.     return;
  2649. }
  2650. if (extType.type() == ExtType::Ubigint) {
  2651.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2652.     *dataPtr = static_cast<SQLUBIGINT>(uvalue);
  2653.     if (indPtr != 0)
  2654. *indPtr = sizeof(SQLUBIGINT);
  2655.     if (extField.m_pos >= 0)
  2656. extField.m_pos = 1;
  2657.     return;
  2658. }
  2659. if (extType.type() == ExtType::Float) {
  2660.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2661.     *dataPtr = static_cast<float>(value); // big enough
  2662.     if (indPtr != 0)
  2663. *indPtr = sizeof(float);
  2664.     if (extField.m_pos >= 0)
  2665. extField.m_pos = 1;
  2666.     return;
  2667. }
  2668. if (extType.type() == ExtType::Double) {
  2669.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2670.     *dataPtr = static_cast<double>(value); // big enough
  2671.     if (indPtr != 0)
  2672. *indPtr = sizeof(double);
  2673.     if (extField.m_pos >= 0)
  2674. extField.m_pos = 1;
  2675.     return;
  2676. }
  2677.     }
  2678.     if (sqlType.type() == SqlType::Bigint) {
  2679. if (extField.m_pos > 0) {
  2680.     ctx.setCode(SQL_NO_DATA);
  2681.     return;
  2682. }
  2683. const SqlBigint value = sqlBigint();
  2684. const SqlUbigint uvalue = value;
  2685. if (extType.type() == ExtType::Char) {
  2686.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2687.     if (! sqlType.unSigned()) {
  2688. if (! copyout_signed_char(ctx, value, dataPtr, extField.m_dataLen, indPtr))
  2689.     return;
  2690.     } else {
  2691. if (! copyout_unsigned_char(ctx, uvalue, dataPtr, extField.m_dataLen, indPtr))
  2692.     return;
  2693.     }
  2694.     if (extField.m_pos >= 0)
  2695. extField.m_pos = 1;
  2696.     return;
  2697. }
  2698. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2699.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2700.     if (value < SHRT_MIN || value > SHRT_MAX) {
  2701. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_I64 " overflow", (Int64)value);
  2702. return;
  2703.     }
  2704.     *dataPtr = static_cast<short>(value);
  2705.     if (indPtr != 0)
  2706. *indPtr = sizeof(short);
  2707.     if (extField.m_pos >= 0)
  2708. extField.m_pos = 1;
  2709.     return;
  2710. }
  2711. if (extType.type() == ExtType::Ushort) {
  2712.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2713.     if (uvalue > USHRT_MAX) {
  2714. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_U64 " overflow", (Uint64)uvalue);
  2715. return;
  2716.     }
  2717.     *dataPtr = static_cast<short>(value);
  2718.     if (indPtr != 0)
  2719. *indPtr = sizeof(unsigned short);
  2720.     if (extField.m_pos >= 0)
  2721. extField.m_pos = 1;
  2722.     return;
  2723. }
  2724. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2725.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2726.     if (value < INT_MIN || value > INT_MAX) {
  2727. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_I64 " overflow", (Int64)value);
  2728. return;
  2729.     }
  2730.     *dataPtr = static_cast<long>(value);
  2731.     if (indPtr != 0)
  2732. *indPtr = sizeof(long);
  2733.     if (extField.m_pos >= 0)
  2734. extField.m_pos = 1;
  2735.     return;
  2736. }
  2737. if (extType.type() == ExtType::Ulong) {
  2738.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2739.     if (uvalue > UINT_MAX) {
  2740. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value " FMT_U64 " overflow", (Uint64)uvalue);
  2741. return;
  2742.     }
  2743.     *dataPtr = static_cast<unsigned long>(uvalue);
  2744.     if (indPtr != 0)
  2745. *indPtr = sizeof(unsigned long);
  2746.     if (extField.m_pos >= 0)
  2747. extField.m_pos = 1;
  2748.     return;
  2749. }
  2750. if (extType.type() == ExtType::Sbigint) {
  2751.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2752.     *dataPtr = static_cast<SQLBIGINT>(value); // big enough
  2753.     if (indPtr != 0)
  2754. *indPtr = sizeof(SQLBIGINT);
  2755.     if (extField.m_pos >= 0)
  2756. extField.m_pos = 1;
  2757.     return;
  2758. }
  2759. if (extType.type() == ExtType::Ubigint) {
  2760.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2761.     *dataPtr = static_cast<SQLUBIGINT>(uvalue);
  2762.     if (indPtr != 0)
  2763. *indPtr = sizeof(SQLUBIGINT);
  2764.     if (extField.m_pos >= 0)
  2765. extField.m_pos = 1;
  2766.     return;
  2767. }
  2768. if (extType.type() == ExtType::Float) {
  2769.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2770.     *dataPtr = static_cast<float>(value); // big enough
  2771.     if (indPtr != 0)
  2772. *indPtr = sizeof(float);
  2773.     if (extField.m_pos >= 0)
  2774. extField.m_pos = 1;
  2775.     return;
  2776. }
  2777. if (extType.type() == ExtType::Double) {
  2778.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2779.     *dataPtr = static_cast<double>(value); // big enough
  2780.     if (indPtr != 0)
  2781. *indPtr = sizeof(double);
  2782.     if (extField.m_pos >= 0)
  2783. extField.m_pos = 1;
  2784.     return;
  2785. }
  2786.     }
  2787.     if (sqlType.type() == SqlType::Real) {
  2788. if (extField.m_pos > 0) {
  2789.     ctx.setCode(SQL_NO_DATA);
  2790.     return;
  2791. }
  2792. const SqlReal value = sqlReal();
  2793. if (extType.type() == ExtType::Char) {
  2794.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2795.     if (! copyout_double_char(ctx, value, 7, dataPtr, extField.m_dataLen, indPtr))
  2796. return;
  2797.     if (extField.m_pos >= 0)
  2798. extField.m_pos = 1;
  2799.     return;
  2800. }
  2801. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2802.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2803.     *dataPtr = static_cast<short>(value); // XXX todo
  2804.     if (indPtr != 0)
  2805. *indPtr = sizeof(short);
  2806.     if (extField.m_pos >= 0)
  2807. extField.m_pos = 1;
  2808.     return;
  2809. }
  2810. if (extType.type() == ExtType::Ushort) {
  2811.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2812.     if (value < 0 || value > USHRT_MAX) {
  2813. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %g overflow", (double)value);
  2814. return;
  2815.     }
  2816.     *dataPtr = static_cast<short>(value);
  2817.     if (indPtr != 0)
  2818. *indPtr = sizeof(unsigned short);
  2819.     if (extField.m_pos >= 0)
  2820. extField.m_pos = 1;
  2821.     return;
  2822. }
  2823. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2824.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2825.     *dataPtr = static_cast<long>(value); // big enough
  2826.     if (indPtr != 0)
  2827. *indPtr = sizeof(long);
  2828.     if (extField.m_pos >= 0)
  2829. extField.m_pos = 1;
  2830.     return;
  2831. }
  2832. if (extType.type() == ExtType::Ulong) {
  2833.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2834.     *dataPtr = static_cast<unsigned long>(value); // XXX todo
  2835.     if (indPtr != 0)
  2836. *indPtr = sizeof(unsigned long);
  2837.     if (extField.m_pos >= 0)
  2838. extField.m_pos = 1;
  2839.     return;
  2840. }
  2841. if (extType.type() == ExtType::Sbigint) {
  2842.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2843.     *dataPtr = static_cast<SQLBIGINT>(value); // big enough
  2844.     if (indPtr != 0)
  2845. *indPtr = sizeof(SQLBIGINT);
  2846.     if (extField.m_pos >= 0)
  2847. extField.m_pos = 1;
  2848.     return;
  2849. }
  2850. if (extType.type() == ExtType::Ubigint) {
  2851.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2852.     *dataPtr = static_cast<SQLUBIGINT>(value);
  2853.     if (indPtr != 0)
  2854. *indPtr = sizeof(SQLUBIGINT);
  2855.     if (extField.m_pos >= 0)
  2856. extField.m_pos = 1;
  2857.     return;
  2858. }
  2859. if (extType.type() == ExtType::Float) {
  2860.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2861.     *dataPtr = static_cast<float>(value); // big enough
  2862.     if (indPtr != 0)
  2863. *indPtr = sizeof(float);
  2864.     if (extField.m_pos >= 0)
  2865. extField.m_pos = 1;
  2866.     return;
  2867. }
  2868. if (extType.type() == ExtType::Double) {
  2869.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2870.     *dataPtr = static_cast<double>(value); // big enough
  2871.     if (indPtr != 0)
  2872. *indPtr = sizeof(double);
  2873.     if (extField.m_pos >= 0)
  2874. extField.m_pos = 1;
  2875.     return;
  2876. }
  2877.     }
  2878.     if (sqlType.type() == SqlType::Double) {
  2879. if (extField.m_pos > 0) {
  2880.     ctx.setCode(SQL_NO_DATA);
  2881.     return;
  2882. }
  2883. SqlDouble value = sqlDouble();
  2884. if (extType.type() == ExtType::Char) {
  2885.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2886.     if (! copyout_double_char(ctx, value, 14, dataPtr, extField.m_dataLen, indPtr))
  2887. return;
  2888.     if (extField.m_pos >= 0)
  2889. extField.m_pos = 1;
  2890.     return;
  2891. }
  2892. if (extType.type() == ExtType::Short || extType.type() == ExtType::Sshort) {
  2893.     short* dataPtr = static_cast<short*>(extField.m_dataPtr);
  2894.     *dataPtr = static_cast<short>(value); // XXX todo
  2895.     if (indPtr != 0)
  2896. *indPtr = sizeof(short);
  2897.     if (extField.m_pos >= 0)
  2898. extField.m_pos = 1;
  2899.     return;
  2900. }
  2901. if (extType.type() == ExtType::Ushort) {
  2902.     unsigned short* dataPtr = static_cast<unsigned short*>(extField.m_dataPtr);
  2903.     if (value < 0 || value > USHRT_MAX) {
  2904. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "value %g overflow", (double)value);
  2905. return;
  2906.     }
  2907.     *dataPtr = static_cast<short>(value);
  2908.     if (indPtr != 0)
  2909. *indPtr = sizeof(unsigned short);
  2910.     if (extField.m_pos >= 0)
  2911. extField.m_pos = 1;
  2912.     return;
  2913. }
  2914. if (extType.type() == ExtType::Long || extType.type() == ExtType::Slong) {
  2915.     long* dataPtr = static_cast<long*>(extField.m_dataPtr);
  2916.     *dataPtr = static_cast<long>(value); // big enough
  2917.     if (indPtr != 0)
  2918. *indPtr = sizeof(long);
  2919.     if (extField.m_pos >= 0)
  2920. extField.m_pos = 1;
  2921.     return;
  2922. }
  2923. if (extType.type() == ExtType::Ulong) {
  2924.     unsigned long* dataPtr = static_cast<unsigned long*>(extField.m_dataPtr);
  2925.     *dataPtr = static_cast<unsigned long>(value); // XXX todo
  2926.     if (indPtr != 0)
  2927. *indPtr = sizeof(unsigned long);
  2928.     if (extField.m_pos >= 0)
  2929. extField.m_pos = 1;
  2930.     return;
  2931. }
  2932. if (extType.type() == ExtType::Sbigint) {
  2933.     SQLBIGINT* dataPtr = static_cast<SQLBIGINT*>(extField.m_dataPtr);
  2934.     *dataPtr = static_cast<SQLBIGINT>(value); // big enough
  2935.     if (indPtr != 0)
  2936. *indPtr = sizeof(SQLBIGINT);
  2937.     if (extField.m_pos >= 0)
  2938. extField.m_pos = 1;
  2939.     return;
  2940. }
  2941. if (extType.type() == ExtType::Ubigint) {
  2942.     SQLUBIGINT* dataPtr = static_cast<SQLUBIGINT*>(extField.m_dataPtr);
  2943.     *dataPtr = static_cast<SQLUBIGINT>(value);
  2944.     if (indPtr != 0)
  2945. *indPtr = sizeof(SQLUBIGINT);
  2946.     if (extField.m_pos >= 0)
  2947. extField.m_pos = 1;
  2948.     return;
  2949. }
  2950. if (extType.type() == ExtType::Float) {
  2951.     float* dataPtr = static_cast<float*>(extField.m_dataPtr);
  2952.     *dataPtr = static_cast<float>(value); // big enough
  2953.     if (indPtr != 0)
  2954. *indPtr = sizeof(float);
  2955.     if (extField.m_pos >= 0)
  2956. extField.m_pos = 1;
  2957.     return;
  2958. }
  2959. if (extType.type() == ExtType::Double) {
  2960.     double* dataPtr = static_cast<double*>(extField.m_dataPtr);
  2961.     *dataPtr = static_cast<double>(value);
  2962.     if (indPtr != 0)
  2963. *indPtr = sizeof(double);
  2964.     if (extField.m_pos >= 0)
  2965. extField.m_pos = 1;
  2966.     return;
  2967. }
  2968.     }
  2969.     if (sqlType.type() == SqlType::Datetime) {
  2970. if (extField.m_pos > 0) {
  2971.     ctx.setCode(SQL_NO_DATA);
  2972.     return;
  2973. }
  2974. SqlDatetime value = sqlDatetime();
  2975. if (extType.type() == ExtType::Char) {
  2976.     char* dataPtr = static_cast<char*>(extField.m_dataPtr);
  2977.     char buf[100];
  2978.     sprintf(buf, "%02d%02u-%02u-%02u40%02u:%02u:%02u.%09u", value.cc(), value.yy(), value.mm(), value.dd(), value.HH(), value.MM(), value.SS(), value.ff());
  2979.     int n = strlen(buf);
  2980.     if (extField.m_dataLen < 20) {
  2981. ctx.pushStatus(Sqlstate::_22003, Error::Gen, "buffer too small for timestamp %s", buf);
  2982. return;
  2983.     }
  2984.     if (extField.m_dataLen < n) {
  2985. ctx.pushStatus(Sqlstate::_01004, Error::Gen, "truncating fractional part of timestamp %s", buf);
  2986. n = extField.m_dataLen;
  2987.     }
  2988.     if (! copyout_char_char(ctx, buf, n, dataPtr, extField.m_dataLen, indPtr, 0))
  2989. return;
  2990.     if (extField.m_pos >= 0)
  2991. extField.m_pos = 1;
  2992.     return;
  2993. }
  2994. if (extType.type() == ExtType::Timestamp) {
  2995.     SQL_TIMESTAMP_STRUCT* dataPtr = static_cast<SQL_TIMESTAMP_STRUCT*>(extField.m_dataPtr);
  2996.     // XXX assume same datatype
  2997.     dataPtr->year = value.cc() * 100 + value.yy();
  2998.     dataPtr->month = value.mm();
  2999.     dataPtr->day = value.dd();
  3000.     dataPtr->hour = value.HH();
  3001.     dataPtr->minute = value.MM();
  3002.     dataPtr->second = value.SS();
  3003.     dataPtr->fraction = value.ff();
  3004.     return;
  3005. }
  3006.     }
  3007.     ctx_assert(false); // SqlType::Null not applicable
  3008. }
  3010. void
  3011. SqlField::print(char* buf, unsigned size) const
  3012. {
  3013.     Ctx ctx;
  3014.     unsigned n = sqlSpec().sqlType().displaySize();
  3015.     SQLINTEGER ind = 0;
  3016.     ExtType extType(ExtType::Char);
  3017.     ExtSpec extSpec(extType);
  3018.     ExtField extField(extSpec, (SQLPOINTER)buf, size, &ind);
  3019.     buf[0] = 0;
  3020.     copyout(ctx, extField);
  3021.     if (ind == SQL_NULL_DATA)
  3022. snprintf(buf, size, "NULL");
  3023. }