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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
data0data.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

data0data.c：源码内容
  1. /************************************************************************
  2. SQL data field and tuple
  4. (c) 1994-1996 Innobase Oy
  6. Created 5/30/1994 Heikki Tuuri
  7. *************************************************************************/
  9. #include "data0data.h"
  11. #ifdef UNIV_NONINL
  12. #include "data0data.ic"
  13. #endif
  15. #include "ut0rnd.h"
  18. byte data_error; /* data pointers of tuple fields are initialized
  19. to point here for error checking */
  21. ulint data_dummy; /* this is used to fool the compiler in
  22. dtuple_validate */
  24. byte data_buf[8192]; /* used in generating test tuples */
  25. ulint data_rnd = 756511;
  28. /* Some non-inlined functions used in the MySQL interface: */
  29. void 
  30. dfield_set_data_noninline(
  31. dfield_t*  field, /* in: field */
  32. void* data, /* in: data */
  33. ulint len) /* in: length or UNIV_SQL_NULL */
  34. {
  35. dfield_set_data(field, data, len);
  36. }
  37. void* 
  38. dfield_get_data_noninline(
  39. dfield_t* field) /* in: field */
  40. {
  41. return(dfield_get_data(field));
  42. }
  43. ulint
  44. dfield_get_len_noninline(
  45. dfield_t* field) /* in: field */
  46. {
  47. return(dfield_get_len(field));
  48. }
  49. ulint 
  50. dtuple_get_n_fields_noninline(
  51. dtuple_t*  tuple) /* in: tuple */
  52. {
  53. return(dtuple_get_n_fields(tuple));
  54. }
  55. dfield_t* 
  56. dtuple_get_nth_field_noninline(
  57. dtuple_t*  tuple, /* in: tuple */
  58. ulint n) /* in: index of field */
  59. {
  60. return(dtuple_get_nth_field(tuple, n));
  61. }
  63. /*************************************************************************
  64. Creates a dtuple for use in MySQL. */
  66. dtuple_t*
  67. dtuple_create_for_mysql(
  68. /*====================*/
  69. /* out, own created dtuple */
  70. void**  heap,     /* out: created memory heap */
  71. ulint  n_fields)  /* in: number of fields */
  72. {
  73.    *heap = (void*)mem_heap_create(500);
  74.  
  75.    return(dtuple_create(*((mem_heap_t**)heap), n_fields));  
  76. }
  78. /*************************************************************************
  79. Frees a dtuple used in MySQL. */
  81. void
  82. dtuple_free_for_mysql(
  83. /*==================*/
  84. void* heap) /* in: memory heap where tuple was created */
  85. {
  86.    mem_heap_free((mem_heap_t*)heap);
  87. }
  89. /*************************************************************************
  90. Sets number of fields used in a tuple. Normally this is set in
  91. dtuple_create, but if you want later to set it smaller, you can use this. */ 
  93. void
  94. dtuple_set_n_fields(
  95. /*================*/
  96. dtuple_t* tuple, /* in: tuple */
  97. ulint n_fields) /* in: number of fields */
  98. {
  99. ut_ad(tuple);
  101. tuple->n_fields = n_fields;
  102. tuple->n_fields_cmp = n_fields;
  103. }
  105. /**************************************************************
  106. Checks that a data field is typed. Asserts an error if not. */
  108. ibool
  109. dfield_check_typed(
  110. /*===============*/
  111. /* out: TRUE if ok */
  112. dfield_t* field) /* in: data field */
  113. {
  114. ut_a(dfield_get_type(field)->mtype <= DATA_SYS);
  115. ut_a(dfield_get_type(field)->mtype >= DATA_VARCHAR);
  117. return(TRUE);
  118. }
  120. /**************************************************************
  121. Checks that a data tuple is typed. Asserts an error if not. */
  123. ibool
  124. dtuple_check_typed(
  125. /*===============*/
  126. /* out: TRUE if ok */
  127. dtuple_t* tuple) /* in: tuple */
  128. {
  129. dfield_t* field;
  130. ulint   i;
  132. for (i = 0; i < dtuple_get_n_fields(tuple); i++) {
  134. field = dtuple_get_nth_field(tuple, i);
  136. ut_a(dfield_check_typed(field));
  137. }
  139. return(TRUE);
  140. }
  142. /**************************************************************
  143. Validates the consistency of a tuple which must be complete, i.e,
  144. all fields must have been set. */
  146. ibool
  147. dtuple_validate(
  148. /*============*/
  149. /* out: TRUE if ok */
  150. dtuple_t* tuple) /* in: tuple */
  151. {
  152. dfield_t* field;
  153. byte*   data;
  154. ulint   n_fields;
  155. ulint   len;
  156. ulint   i;
  157. ulint   j;
  159. ut_a(tuple->magic_n = DATA_TUPLE_MAGIC_N);
  161. n_fields = dtuple_get_n_fields(tuple);
  163. /* We dereference all the data of each field to test
  164. for memory traps */
  166. for (i = 0; i < n_fields; i++) {
  168. field = dtuple_get_nth_field(tuple, i);
  169. len = dfield_get_len(field);
  171. if (len != UNIV_SQL_NULL) {
  173. data = field->data;
  175. for (j = 0; j < len; j++) {
  177. data_dummy  += *data; /* fool the compiler not
  178. to optimize out this
  179. code */
  180. data++;
  181. }
  182. }
  183. }
  185. ut_a(dtuple_check_typed(tuple));
  187. return(TRUE);
  188. }
  190. /*****************************************************************
  191. Pretty prints a dfield value according to its data type. */
  193. void
  194. dfield_print(
  195. /*=========*/
  196. dfield_t* dfield)  /* in: dfield */
  197. {
  198. byte* data;
  199. ulint len;
  200. ulint mtype;
  201. ulint i;
  203. len = dfield_get_len(dfield);
  204. data = dfield_get_data(dfield);
  206. if (len == UNIV_SQL_NULL) {
  207. printf("NULL");
  209. return;
  210. }
  212. mtype = dtype_get_mtype(dfield_get_type(dfield));
  214. if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
  216. for (i = 0; i < len; i++) {
  218. if (isprint((char)(*data))) {
  219. printf("%c", (char)*data);
  220. } else {
  221. printf(" ");
  222. }
  224. data++;
  225. }
  226. } else if (mtype == DATA_INT) {
  227. ut_a(len == 4); /* only works for 32-bit integers */
  228. printf("%i", (int)mach_read_from_4(data));
  229. } else {
  230. ut_error;
  231. }
  232. }
  234. /*****************************************************************
  235. Pretty prints a dfield value according to its data type. Also the hex string
  236. is printed if a string contains non-printable characters. */ 
  238. void
  239. dfield_print_also_hex(
  240. /*==================*/
  241. dfield_t* dfield)  /* in: dfield */
  242. {
  243. byte* data;
  244. ulint len;
  245. ulint mtype;
  246. ulint i;
  247. ibool print_also_hex;
  249. len = dfield_get_len(dfield);
  250. data = dfield_get_data(dfield);
  252. if (len == UNIV_SQL_NULL) {
  253. printf("NULL");
  255. return;
  256. }
  258. mtype = dtype_get_mtype(dfield_get_type(dfield));
  260. if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
  262. print_also_hex = FALSE;
  264. for (i = 0; i < len; i++) {
  266. if (isprint((char)(*data))) {
  267. printf("%c", (char)*data);
  268. } else {
  269. print_also_hex = TRUE;
  270. printf(" ");
  271. }
  273. data++;
  274. }
  276. if (!print_also_hex) {
  278. return;
  279. }
  281. printf(" Hex: ");
  283. data = dfield_get_data(dfield);
  285. for (i = 0; i < len; i++) {
  286. printf("%02lx", (ulint)*data);
  288. data++;
  289. }
  290. } else if (mtype == DATA_INT) {
  291. ut_a(len == 4); /* inly works for 32-bit integers */
  292. printf("%i", (int)mach_read_from_4(data));
  293. } else {
  294. ut_error;
  295. }
  296. }
  298. /**************************************************************
  299. The following function prints the contents of a tuple. */
  301. void
  302. dtuple_print(
  303. /*=========*/
  304. dtuple_t* tuple) /* in: tuple */
  305. {
  306. dfield_t* field;
  307. ulint n_fields;
  308. ulint i;
  310. n_fields = dtuple_get_n_fields(tuple);
  312. printf("DATA TUPLE: %lu fields;n", n_fields);
  314. for (i = 0; i < n_fields; i++) {
  315. printf(" %lu:", i);
  317. field = dtuple_get_nth_field(tuple, i);
  319. if (field->len != UNIV_SQL_NULL) {
  320. ut_print_buf(field->data, field->len);
  321. } else {
  322. printf(" SQL NULL");
  323. }
  325. printf(";");
  326. }
  328. printf("n");
  330. dtuple_validate(tuple);
  331. }
  333. /**************************************************************
  334. The following function prints the contents of a tuple to a buffer. */
  336. ulint
  337. dtuple_sprintf(
  338. /*===========*/
  339. /* out: printed length in bytes */
  340. char* buf, /* in: print buffer */
  341. ulint buf_len,/* in: buf length in bytes */
  342. dtuple_t* tuple) /* in: tuple */
  343. {
  344. dfield_t* field;
  345. ulint n_fields;
  346. ulint len;
  347. ulint i;
  349. len = 0;
  351. n_fields = dtuple_get_n_fields(tuple);
  353. for (i = 0; i < n_fields; i++) {
  354. if (len + 30 > buf_len) {
  356. return(len);
  357. }
  359. len += sprintf(buf + len, " %lu:", i);
  361. field = dtuple_get_nth_field(tuple, i);
  363. if (field->len != UNIV_SQL_NULL) {
  364. if (5 * field->len + len + 30 > buf_len) {
  366. return(len);
  367. }
  369. len += ut_sprintf_buf(buf + len, field->data,
  370. field->len);
  371. } else {
  372. len += sprintf(buf + len, " SQL NULL");
  373. }
  375. len += sprintf(buf + len, ";");
  376. }
  378. return(len);
  379. }
  381. #ifdef notdefined
  383. /******************************************************************
  384. Generates random numbers, where 10/16 is uniformly
  385. distributed between 0 and n1, 5/16 between 0 and n2,
  386. and 1/16 between 0 and n3. */
  387. static
  388. ulint
  389. dtuple_gen_rnd_ulint(
  390. /*=================*/
  391. /* out: random ulint */
  392. ulint n1,
  393. ulint n2,
  394. ulint n3)
  395. {
  396. ulint  m;
  397. ulint n;
  399. m = ut_rnd_gen_ulint() % 16;
  401. if (m < 10) {
  402. n = n1;
  403. } else if (m < 15) {
  404. n = n2;
  405. } else {
  406. n = n3;
  407. }
  409. m = ut_rnd_gen_ulint();
  411. return(m % n);
  412. }
  414. /***************************************************************
  415. Generates a random tuple. */
  417. dtuple_t*
  418. dtuple_gen_rnd_tuple(
  419. /*=================*/
  420. /* out: pointer to the tuple */
  421. mem_heap_t* heap) /* in: memory heap where generated */
  422. {
  423. ulint n_fields;
  424. dfield_t* field;
  425. ulint len;
  426. dtuple_t* tuple;
  427. ulint i;
  428. ulint j;
  429. byte* ptr;
  431. n_fields = dtuple_gen_rnd_ulint(5, 30, 300) + 1;
  433. tuple = dtuple_create(heap, n_fields);
  435. for (i = 0; i < n_fields; i++) {
  437. if (n_fields < 7) {
  438. len = dtuple_gen_rnd_ulint(5, 30, 400);
  439. } else {
  440. len = dtuple_gen_rnd_ulint(7, 5, 17);
  441. }
  443. field = dtuple_get_nth_field(tuple, i);
  445. if (len == 0) {
  446. dfield_set_data(field, NULL, UNIV_SQL_NULL);
  447. } else {
  448. ptr = mem_heap_alloc(heap, len);
  449. dfield_set_data(field, ptr, len - 1);
  451. for (j = 0; j < len; j++) {
  452. *ptr = (byte)(65 + 
  453. dtuple_gen_rnd_ulint(22, 22, 22));
  454. ptr++;
  455. }
  456. }
  458. dtype_set(dfield_get_type(field), DATA_VARCHAR,
  459. DATA_ENGLISH, 500, 0);
  460. }
  462. ut_a(dtuple_validate(tuple));
  464. return(tuple);
  465. }
  467. /*******************************************************************
  468. Generates a test tuple for sort and comparison tests. */
  470. void
  471. dtuple_gen_test_tuple(
  472. /*==================*/
  473. dtuple_t* tuple, /* in/out: a tuple with 3 fields */
  474. ulint i) /* in: a number < 512 */
  475. {
  476. ulint j;
  477. dfield_t* field;
  478. void* data = NULL;
  479. ulint len = 0;
  481. for (j = 0; j < 3; j++) {
  482. switch (i % 8) {
  483. case 0:
  484. data = ""; len = 0; break;
  485. case 1:
  486. data = "A"; len = 1; break;
  487. case 2:
  488. data = "AA"; len = 2; break;
  489. case 3:
  490. data = "AB"; len = 2; break;
  491. case 4:
  492. data = "B"; len = 1; break;
  493. case 5:
  494. data = "BA"; len = 2; break;
  495. case 6:
  496. data = "BB"; len = 2; break;
  497. case 7:
  498. len = UNIV_SQL_NULL; break;
  499. }
  501. field = dtuple_get_nth_field(tuple, 2 - j);
  503. dfield_set_data(field, data, len);
  504. dtype_set(dfield_get_type(field), DATA_VARCHAR,
  505. DATA_ENGLISH, 100, 0);
  507. i = i / 8;
  508. }
  510. ut_ad(dtuple_validate(tuple));
  511. }
  513. /*******************************************************************
  514. Generates a test tuple for B-tree speed tests. */
  516. void
  517. dtuple_gen_test_tuple3(
  518. /*===================*/
  519. dtuple_t* tuple, /* in/out: a tuple with >= 3 fields */
  520. ulint i, /* in: a number < 1000000 */
  521. ulint type, /* in: DTUPLE_TEST_FIXED30, ... */
  522. byte* buf) /* in: a buffer of size >= 16 bytes */
  523. {
  524. dfield_t* field;
  525. ulint third_size;
  527. ut_ad(tuple && buf);
  528. ut_ad(i < 1000000);
  530. field = dtuple_get_nth_field(tuple, 0);
  532. ut_strcpy((char*)buf, "0000000");
  534. buf[1] = (byte)('0' + (i / 100000) % 10);
  535. buf[2] = (byte)('0' + (i / 10000) % 10);
  536. buf[3] = (byte)('0' + (i / 1000) % 10);
  537. buf[4] = (byte)('0' + (i / 100) % 10);
  538. buf[5] = (byte)('0' + (i / 10) % 10);
  539. buf[6] = (byte)('0' + (i % 10));
  541. dfield_set_data(field, buf, 8);
  542. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  544. field = dtuple_get_nth_field(tuple, 1);
  546. i = i % 1000; /* ut_rnd_gen_ulint() % 1000000; */
  548. ut_strcpy((char*)buf + 8, "0000000");
  550. buf[9] = (byte)('0' + (i / 100000) % 10);
  551. buf[10] = (byte)('0' + (i / 10000) % 10);
  552. buf[11] = (byte)('0' + (i / 1000) % 10);
  553. buf[12] = (byte)('0' + (i / 100) % 10);
  554. buf[13] = (byte)('0' + (i / 10) % 10);
  555. buf[14] = (byte)('0' + (i % 10));
  557. dfield_set_data(field, buf + 8, 8);
  558. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  560. field = dtuple_get_nth_field(tuple, 2);
  562. data_rnd += 8757651;
  564. if (type == DTUPLE_TEST_FIXED30) {
  565. third_size = 30;
  566. } else if (type == DTUPLE_TEST_RND30) {
  567. third_size = data_rnd % 30;
  568. } else if (type == DTUPLE_TEST_RND3500) {
  569. third_size = data_rnd % 3500;
  570. } else if (type == DTUPLE_TEST_FIXED2000) {
  571. third_size = 2000;
  572. } else if (type == DTUPLE_TEST_FIXED3) {
  573. third_size = 3;
  574. } else {
  575. ut_error;
  576. }
  578. if (type == DTUPLE_TEST_FIXED30) {
  579. dfield_set_data(field,
  580. "12345678901234567890123456789", third_size);
  581. } else {
  582. dfield_set_data(field, data_buf, third_size);
  583. }
  585. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  587. ut_ad(dtuple_validate(tuple));
  588. }
  590. /*******************************************************************
  591. Generates a test tuple for B-tree speed tests. */
  593. void
  594. dtuple_gen_search_tuple3(
  595. /*=====================*/
  596. dtuple_t* tuple, /* in/out: a tuple with 1 or 2 fields */
  597. ulint i, /* in: a number < 1000000 */
  598. byte* buf) /* in: a buffer of size >= 16 bytes */
  599. {
  600. dfield_t* field;
  602. ut_ad(tuple && buf);
  603. ut_ad(i < 1000000);
  605. field = dtuple_get_nth_field(tuple, 0);
  607. ut_strcpy((char*)buf, "0000000");
  609. buf[1] = (byte)('0' + (i / 100000) % 10);
  610. buf[2] = (byte)('0' + (i / 10000) % 10);
  611. buf[3] = (byte)('0' + (i / 1000) % 10);
  612. buf[4] = (byte)('0' + (i / 100) % 10);
  613. buf[5] = (byte)('0' + (i / 10) % 10);
  614. buf[6] = (byte)('0' + (i % 10));
  616. dfield_set_data(field, buf, 8);
  617. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  619. if (dtuple_get_n_fields(tuple) == 1) {
  621. return;
  622. }
  624. field = dtuple_get_nth_field(tuple, 1);
  626. i = (i * 1000) % 1000000;
  628. ut_strcpy((char*)buf + 8, "0000000");
  630. buf[9] = (byte)('0' + (i / 100000) % 10);
  631. buf[10] = (byte)('0' + (i / 10000) % 10);
  632. buf[11] = (byte)('0' + (i / 1000) % 10);
  633. buf[12] = (byte)('0' + (i / 100) % 10);
  634. buf[13] = (byte)('0' + (i / 10) % 10);
  635. buf[14] = (byte)('0' + (i % 10));
  637. dfield_set_data(field, buf + 8, 8);
  638. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  640. ut_ad(dtuple_validate(tuple));
  641. }
  643. /*******************************************************************
  644. Generates a test tuple for TPC-A speed test. */
  646. void
  647. dtuple_gen_test_tuple_TPC_A(
  648. /*========================*/
  649. dtuple_t* tuple, /* in/out: a tuple with >= 3 fields */
  650. ulint i, /* in: a number < 10000 */
  651. byte* buf) /* in: a buffer of size >= 16 bytes */
  652. {
  653. dfield_t* field;
  654. ulint third_size;
  656. ut_ad(tuple && buf);
  657. ut_ad(i < 10000);
  659. field = dtuple_get_nth_field(tuple, 0);
  661. ut_strcpy((char*)buf, "0000");
  663. buf[0] = (byte)('0' + (i / 1000) % 10);
  664. buf[1] = (byte)('0' + (i / 100) % 10);
  665. buf[2] = (byte)('0' + (i / 10) % 10);
  666. buf[3] = (byte)('0' + (i % 10));
  668. dfield_set_data(field, buf, 5);
  669. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  671. field = dtuple_get_nth_field(tuple, 1);
  673. dfield_set_data(field, buf + 8, 5);
  674. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  676. field = dtuple_get_nth_field(tuple, 2);
  678. third_size = 90;
  680. dfield_set_data(field, data_buf, third_size);
  681. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  683. ut_ad(dtuple_validate(tuple));
  684. }
  686. /*******************************************************************
  687. Generates a test tuple for B-tree speed tests. */
  689. void
  690. dtuple_gen_search_tuple_TPC_A(
  691. /*==========================*/
  692. dtuple_t* tuple, /* in/out: a tuple with 1 field */
  693. ulint i, /* in: a number < 10000 */
  694. byte* buf) /* in: a buffer of size >= 16 bytes */
  695. {
  696. dfield_t* field;
  698. ut_ad(tuple && buf);
  699. ut_ad(i < 10000);
  701. field = dtuple_get_nth_field(tuple, 0);
  703. ut_strcpy((char*)buf, "0000");
  705. buf[0] = (byte)('0' + (i / 1000) % 10);
  706. buf[1] = (byte)('0' + (i / 100) % 10);
  707. buf[2] = (byte)('0' + (i / 10) % 10);
  708. buf[3] = (byte)('0' + (i % 10));
  710. dfield_set_data(field, buf, 5);
  711. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  713. ut_ad(dtuple_validate(tuple));
  714. }
  716. /*******************************************************************
  717. Generates a test tuple for TPC-C speed test. */
  719. void
  720. dtuple_gen_test_tuple_TPC_C(
  721. /*========================*/
  722. dtuple_t* tuple, /* in/out: a tuple with >= 12 fields */
  723. ulint i, /* in: a number < 100000 */
  724. byte* buf) /* in: a buffer of size >= 16 bytes */
  725. {
  726. dfield_t* field;
  727. ulint size;
  728. ulint j;
  730. ut_ad(tuple && buf);
  731. ut_ad(i < 100000);
  733. field = dtuple_get_nth_field(tuple, 0);
  735. buf[0] = (byte)('0' + (i / 10000) % 10);
  736. buf[1] = (byte)('0' + (i / 1000) % 10);
  737. buf[2] = (byte)('0' + (i / 100) % 10);
  738. buf[3] = (byte)('0' + (i / 10) % 10);
  739. buf[4] = (byte)('0' + (i % 10));
  741. dfield_set_data(field, buf, 5);
  742. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  744. field = dtuple_get_nth_field(tuple, 1);
  746. dfield_set_data(field, buf, 5);
  747. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  749. for (j = 0; j < 10; j++) {
  751. field = dtuple_get_nth_field(tuple, 2 + j);
  753. size = 24;
  755. dfield_set_data(field, data_buf, size);
  756. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH,
  757. 100, 0);
  758. }
  760. ut_ad(dtuple_validate(tuple));
  761. }
  763. /*******************************************************************
  764. Generates a test tuple for B-tree speed tests. */
  766. void
  767. dtuple_gen_search_tuple_TPC_C(
  768. /*==========================*/
  769. dtuple_t* tuple, /* in/out: a tuple with 1 field */
  770. ulint i, /* in: a number < 100000 */
  771. byte* buf) /* in: a buffer of size >= 16 bytes */
  772. {
  773. dfield_t* field;
  775. ut_ad(tuple && buf);
  776. ut_ad(i < 100000);
  778. field = dtuple_get_nth_field(tuple, 0);
  780. buf[0] = (byte)('0' + (i / 10000) % 10);
  781. buf[1] = (byte)('0' + (i / 1000) % 10);
  782. buf[2] = (byte)('0' + (i / 100) % 10);
  783. buf[3] = (byte)('0' + (i / 10) % 10);
  784. buf[4] = (byte)('0' + (i % 10));
  786. dfield_set_data(field, buf, 5);
  787. dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
  789. ut_ad(dtuple_validate(tuple));
  790. }
  792. #endif /* notdefined */