← Back to branch summary

~kalebral-deactivatedaccount/drizzle/change-error_num_to_enum-2

« back to all changes in this revision

Viewing changes to plugin/embedded_innodb/embedded_innodb_engine.cc

Merge Stewart.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/embedded_innodb/embedded_innodb_engine.cc
231
231
  return (ib_trx_t*) session->getEngineData(embedded_innodb_engine);
232
232
}
233
233
 
 
234
/* This is a superset of the map from innobase plugin.
 
235
   Unlike innobase plugin we don't act on errors here, we just
 
236
   map error codes. */
 
237
static int ib_err_t_to_drizzle_error(ib_err_t err)
 
238
{
 
239
  switch (err)
 
240
  {
 
241
  case DB_SUCCESS:
 
242
    return 0;
 
243
 
 
244
  case DB_ERROR:
 
245
  default:
 
246
    return -1;
 
247
 
 
248
  case DB_INTERRUPTED:
 
249
    return ER_QUERY_INTERRUPTED; // FIXME: is this correct?
 
250
 
 
251
  case DB_OUT_OF_MEMORY:
 
252
    return HA_ERR_OUT_OF_MEM;
 
253
 
 
254
  case DB_DUPLICATE_KEY:
 
255
    return HA_ERR_FOUND_DUPP_KEY;
 
256
 
 
257
  case DB_FOREIGN_DUPLICATE_KEY:
 
258
    return HA_ERR_FOREIGN_DUPLICATE_KEY;
 
259
 
 
260
  case DB_MISSING_HISTORY:
 
261
    return HA_ERR_TABLE_DEF_CHANGED;
 
262
 
 
263
  case DB_RECORD_NOT_FOUND:
 
264
    return HA_ERR_NO_ACTIVE_RECORD;
 
265
 
 
266
  case DB_DEADLOCK:
 
267
    return HA_ERR_LOCK_DEADLOCK;
 
268
 
 
269
  case DB_LOCK_WAIT_TIMEOUT:
 
270
    return HA_ERR_LOCK_WAIT_TIMEOUT;
 
271
 
 
272
  case DB_NO_REFERENCED_ROW:
 
273
    return HA_ERR_NO_REFERENCED_ROW;
 
274
 
 
275
  case DB_ROW_IS_REFERENCED:
 
276
    return HA_ERR_ROW_IS_REFERENCED;
 
277
 
 
278
  case DB_CANNOT_ADD_CONSTRAINT:
 
279
    return HA_ERR_CANNOT_ADD_FOREIGN;
 
280
 
 
281
  case DB_CANNOT_DROP_CONSTRAINT:
 
282
    return HA_ERR_ROW_IS_REFERENCED; /* misleading. should have new err code */
 
283
 
 
284
  case DB_COL_APPEARS_TWICE_IN_INDEX:
 
285
  case DB_CORRUPTION:
 
286
    return HA_ERR_CRASHED;
 
287
 
 
288
  case DB_MUST_GET_MORE_FILE_SPACE:
 
289
  case DB_OUT_OF_FILE_SPACE:
 
290
    return HA_ERR_RECORD_FILE_FULL;
 
291
 
 
292
  case DB_TABLE_IS_BEING_USED:
 
293
    return HA_ERR_WRONG_COMMAND;
 
294
 
 
295
  case DB_TABLE_NOT_FOUND:
 
296
    return HA_ERR_NO_SUCH_TABLE;
 
297
 
 
298
  case DB_TOO_BIG_RECORD:
 
299
    return HA_ERR_TO_BIG_ROW;
 
300
 
 
301
  case DB_NO_SAVEPOINT:
 
302
    return HA_ERR_NO_SAVEPOINT;
 
303
 
 
304
  case DB_LOCK_TABLE_FULL:
 
305
    return HA_ERR_LOCK_TABLE_FULL;
 
306
 
 
307
  case DB_PRIMARY_KEY_IS_NULL:
 
308
    return ER_PRIMARY_CANT_HAVE_NULL;
 
309
 
 
310
  case DB_TOO_MANY_CONCURRENT_TRXS:
 
311
    return HA_ERR_RECORD_FILE_FULL; /* need better error code */
 
312
 
 
313
  case DB_END_OF_INDEX:
 
314
    return HA_ERR_END_OF_FILE;
 
315
 
 
316
  case DB_UNSUPPORTED:
 
317
    return HA_ERR_UNSUPPORTED;
 
318
  }
 
319
}
 
320
 
234
321
static ib_trx_level_t tx_isolation_to_ib_trx_level(enum_tx_isolation level)
235
322
{
236
323
  switch(level)
295
382
 
296
383
  err= ib_savepoint_rollback(*transaction, savepoint.getName().c_str(),
297
384
                             savepoint.getName().length());
298
 
  if (err != DB_SUCCESS)
299
 
    return -1;
300
385
 
301
 
  return 0;
 
386
  return ib_err_t_to_drizzle_error(err);
302
387
}
303
388
 
304
389
int EmbeddedInnoDBEngine::doReleaseSavepoint(Session* session,
310
395
  err= ib_savepoint_release(*transaction, savepoint.getName().c_str(),
311
396
                            savepoint.getName().length());
312
397
  if (err != DB_SUCCESS)
313
 
    return -1;
 
398
    return ib_err_t_to_drizzle_error(err);
314
399
 
315
400
  return 0;
316
401
}
325
410
    err= ib_trx_commit(*transaction);
326
411
 
327
412
    if (err != DB_SUCCESS)
328
 
      return -1;
 
413
      return ib_err_t_to_drizzle_error(err);
329
414
 
330
415
    *transaction= NULL;
331
416
  }
343
428
    err= ib_trx_rollback(*transaction);
344
429
 
345
430
    if (err != DB_SUCCESS)
346
 
      return -1;
 
431
      return ib_err_t_to_drizzle_error(err);
347
432
 
348
433
    *transaction= NULL;
349
434
  }
352
437
    err= ib_savepoint_rollback(*transaction, statement_savepoint_name.c_str(),
353
438
                               statement_savepoint_name.length());
354
439
    if (err != DB_SUCCESS)
355
 
      return -1;
 
440
      return ib_err_t_to_drizzle_error(err);
356
441
  }
357
442
 
358
443
  return 0;
605
690
  *nb_reserved_values= 1;
606
691
}
607
692
 
 
693
static const char* table_path_to_innodb_name(const char* name)
 
694
{
 
695
  size_t l= strlen(name);
 
696
 
 
697
  int slashes= 2;
 
698
  while(slashes>0 && l > 0)
 
699
  {
 
700
    l--;
 
701
    if (name[l] == '/')
 
702
      slashes--;
 
703
  }
 
704
  if (slashes==0)
 
705
    l++;
 
706
 
 
707
  return &name[l];
 
708
}
 
709
 
608
710
static void TableIdentifier_to_innodb_name(const TableIdentifier &identifier, std::string *str)
609
711
{
610
 
  str->reserve(identifier.getSchemaName().length() + identifier.getTableName().length() + 1);
611
 
//  str->append(identifier.getPath().c_str()+2);
612
 
  str->assign(identifier.getSchemaName());
613
 
  str->append("/");
614
 
  str->append(identifier.getTableName());
 
712
  str->assign(table_path_to_innodb_name(identifier.getPath().c_str()));
615
713
}
616
714
 
617
715
EmbeddedInnoDBCursor::EmbeddedInnoDBCursor(drizzled::plugin::StorageEngine &engine_arg,
618
716
                           TableShare &table_arg)
619
717
  :Cursor(engine_arg, table_arg),
 
718
   ib_lock_mode(IB_LOCK_NONE),
620
719
   write_can_replace(false),
621
720
   blobroot(NULL)
622
721
{ }
623
722
 
 
723
static unsigned int get_first_unique_index(drizzled::Table &table)
 
724
{
 
725
  for (uint32_t k= 0; k < table.getShare()->keys; k++)
 
726
  {
 
727
    if (table.key_info[k].flags & HA_NOSAME)
 
728
    {
 
729
      return k;
 
730
    }
 
731
  }
 
732
 
 
733
  return 0;
 
734
}
 
735
 
624
736
int EmbeddedInnoDBCursor::open(const char *name, int, uint32_t)
625
737
{
626
 
  ib_err_t err= ib_cursor_open_table(name+2, NULL, &cursor);
 
738
  const char* innodb_table_name= table_path_to_innodb_name(name);
 
739
  ib_err_t err= ib_cursor_open_table(innodb_table_name, NULL, &cursor);
627
740
  bool has_hidden_primary_key= false;
628
 
  assert (err == DB_SUCCESS);
629
741
  ib_id_t idx_id;
630
742
 
631
 
  err= ib_index_get_id(name+2, "HIDDEN_PRIMARY", &idx_id);
 
743
  if (err != DB_SUCCESS)
 
744
    return ib_err_t_to_drizzle_error(err);
 
745
 
 
746
  err= ib_index_get_id(innodb_table_name, "HIDDEN_PRIMARY", &idx_id);
 
747
 
632
748
  if (err == DB_SUCCESS)
633
749
    has_hidden_primary_key= true;
634
750
 
643
759
    ref_length= sizeof(uint64_t);
644
760
  else
645
761
  {
646
 
    ref_length= 0; // FIXME: this is a bug. we need to work out what index it is.
 
762
    unsigned int keynr= get_first_unique_index(*table);
 
763
    ref_length= table->key_info[keynr].key_length;
647
764
  }
648
765
 
649
766
  in_table_scan= false;
655
772
{
656
773
  ib_err_t err= ib_cursor_close(cursor);
657
774
  if (err != DB_SUCCESS)
658
 
    return -1; // FIXME
 
775
    return ib_err_t_to_drizzle_error(err);
659
776
 
660
777
  free_share();
661
778
 
670
787
  ib_cursor_stmt_begin(cursor);
671
788
 
672
789
  (void)session;
673
 
  (void)lock_type;
 
790
 
 
791
  if (lock_type == F_WRLCK)
 
792
  {
 
793
    /* SELECT ... FOR UPDATE or UPDATE TABLE */
 
794
    ib_lock_mode= IB_LOCK_X;
 
795
  }
 
796
  else
 
797
    ib_lock_mode= IB_LOCK_NONE;
674
798
 
675
799
  return 0;
676
800
}
835
959
 
836
960
  (void)table_obj;
837
961
 
 
962
  if (table_message.type() == message::Table::TEMPORARY)
 
963
  {
 
964
    ib_bool_t create_db_err= ib_database_create(GLOBAL_TEMPORARY_EXT);
 
965
    if (create_db_err != IB_TRUE)
 
966
      return -1;
 
967
  }
 
968
 
838
969
  TableIdentifier_to_innodb_name(identifier, &innodb_table_name);
839
970
 
840
971
  ib_tbl_fmt_t innodb_table_format= IB_TBL_COMPACT;
859
990
                        ER_CANT_CREATE_TABLE,
860
991
                        _("Cannot create table %s. InnoDB Error %d (%s)\n"),
861
992
                        innodb_table_name.c_str(), innodb_err, ib_strerror(innodb_err));
862
 
    return HA_ERR_GENERIC;
 
993
    return ib_err_t_to_drizzle_error(innodb_err);
863
994
  }
864
995
 
865
996
  for (int colnr= 0; colnr < table_message.field_size() ; colnr++)
880
1011
                            " InnoDB Error %d (%s)\n"),
881
1012
                          field.name().c_str(), innodb_table_name.c_str(),
882
1013
                          innodb_err, ib_strerror(innodb_err));
883
 
      return HA_ERR_GENERIC;
 
1014
      return ib_err_t_to_drizzle_error(innodb_err);
884
1015
    }
885
1016
    if (field_err != 0)
886
1017
      return field_err;
995
1126
    return HA_ERR_GENERIC;
996
1127
  }
997
1128
 
998
 
  innodb_err= store_table_message(innodb_schema_transaction,
999
 
                                  innodb_table_name.c_str(),
1000
 
                                  table_message);
 
1129
  if (table_message.type() == message::Table::TEMPORARY)
 
1130
  {
 
1131
    session.storeTableMessage(identifier, table_message);
 
1132
    innodb_err= DB_SUCCESS;
 
1133
  }
 
1134
  else
 
1135
    innodb_err= store_table_message(innodb_schema_transaction,
 
1136
                                    innodb_table_name.c_str(),
 
1137
                                    table_message);
1001
1138
 
1002
1139
  if (innodb_err == DB_SUCCESS)
1003
1140
    innodb_err= ib_trx_commit(innodb_schema_transaction);
1014
1151
                        _("Cannot create table %s. InnoDB Error %d (%s)\n"),
1015
1152
                        innodb_table_name.c_str(),
1016
1153
                        innodb_err, ib_strerror(innodb_err));
1017
 
    return HA_ERR_GENERIC;
 
1154
    return ib_err_t_to_drizzle_error(innodb_err);
1018
1155
  }
1019
1156
 
1020
1157
  return 0;
1081
1218
    return HA_ERR_GENERIC;
1082
1219
  }
1083
1220
 
1084
 
  if (delete_table_message_from_innodb(innodb_schema_transaction, innodb_table_name.c_str()) != DB_SUCCESS)
1085
 
  {
1086
 
    ib_schema_unlock(innodb_schema_transaction);
1087
 
    ib_err_t rollback_err= ib_trx_rollback(innodb_schema_transaction);
1088
 
    assert(rollback_err == DB_SUCCESS);
1089
 
    return HA_ERR_GENERIC;
 
1221
  if (identifier.getType() == message::Table::TEMPORARY)
 
1222
  {
 
1223
      session.removeTableMessage(identifier);
 
1224
      delete_table_message_from_innodb(innodb_schema_transaction,
 
1225
                                       innodb_table_name.c_str());
 
1226
  }
 
1227
  else
 
1228
  {
 
1229
    if (delete_table_message_from_innodb(innodb_schema_transaction, innodb_table_name.c_str()) != DB_SUCCESS)
 
1230
    {
 
1231
      ib_schema_unlock(innodb_schema_transaction);
 
1232
      ib_err_t rollback_err= ib_trx_rollback(innodb_schema_transaction);
 
1233
      assert(rollback_err == DB_SUCCESS);
 
1234
      return HA_ERR_GENERIC;
 
1235
    }
1090
1236
  }
1091
1237
 
1092
1238
  innodb_err= ib_table_drop(innodb_schema_transaction, innodb_table_name.c_str());
1229
1375
  string from_innodb_table_name;
1230
1376
  string to_innodb_table_name;
1231
1377
 
 
1378
  if (to.getType() == message::Table::TEMPORARY
 
1379
      && from.getType() == message::Table::TEMPORARY)
 
1380
  {
 
1381
    session.renameTableMessage(from, to);
 
1382
    return 0;
 
1383
  }
 
1384
 
1232
1385
  TableIdentifier_to_innodb_name(from, &from_innodb_table_name);
1233
1386
  TableIdentifier_to_innodb_name(to, &to_innodb_table_name);
1234
1387
 
1265
1418
  assert(rollback_err == DB_SUCCESS);
1266
1419
  rollback_err= ib_trx_rollback(innodb_schema_transaction);
1267
1420
  assert(rollback_err == DB_SUCCESS);
1268
 
  return -1;
 
1421
  return ib_err_t_to_drizzle_error(err);
1269
1422
}
1270
1423
 
1271
1424
void EmbeddedInnoDBEngine::getTableNamesInSchemaFromInnoDB(
1477
1630
  return -1;
1478
1631
}
1479
1632
 
1480
 
int EmbeddedInnoDBEngine::doGetTableDefinition(Session&,
 
1633
int EmbeddedInnoDBEngine::doGetTableDefinition(Session &session,
1481
1634
                                               const TableIdentifier &identifier,
1482
1635
                                               drizzled::message::Table &table)
1483
1636
{
1484
1637
  ib_crsr_t innodb_cursor= NULL;
1485
1638
  string innodb_table_name;
1486
1639
 
 
1640
  /* Check temporary tables!? */
 
1641
  if (session.getTableMessage(identifier, table))
 
1642
    return EEXIST;
 
1643
 
1487
1644
  TableIdentifier_to_innodb_name(identifier, &innodb_table_name);
1488
1645
 
1489
1646
  if (ib_cursor_open_table(innodb_table_name.c_str(), NULL, &innodb_cursor) != DB_SUCCESS)
1731
1888
      ret= HA_ERR_FOUND_DUPP_KEY;
1732
1889
  }
1733
1890
  else if (err != DB_SUCCESS)
1734
 
    ret= -1;
 
1891
    ret= ib_err_t_to_drizzle_error(err);
1735
1892
 
1736
1893
  tuple= ib_tuple_clear(tuple);
1737
1894
  ib_tuple_delete(tuple);
1834
1991
 
1835
1992
int EmbeddedInnoDBCursor::doStartTableScan(bool)
1836
1993
{
 
1994
  ib_err_t err;
1837
1995
  ib_trx_t transaction;
1838
1996
 
1839
1997
  if (in_table_scan)
1846
2004
 
1847
2005
  ib_cursor_attach_trx(cursor, transaction);
1848
2006
 
 
2007
  err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
 
2008
  assert(err == DB_SUCCESS); // FIXME
 
2009
 
1849
2010
  tuple= ib_clust_read_tuple_create(cursor);
1850
2011
 
1851
 
  ib_err_t err= ib_cursor_first(cursor);
 
2012
  err= ib_cursor_first(cursor);
1852
2013
  if (err != DB_SUCCESS && err != DB_END_OF_INDEX)
1853
 
    return -1; // FIXME
 
2014
  {
 
2015
    previous_error= ib_err_t_to_drizzle_error(err);
 
2016
    err= ib_cursor_reset(cursor);
 
2017
    return previous_error;
 
2018
  }
1854
2019
 
1855
2020
  advance_cursor= false;
1856
2021
 
 
2022
  previous_error= 0;
1857
2023
  return(0);
1858
2024
}
1859
2025
 
1944
2110
  ib_err_t err;
1945
2111
  int ret;
1946
2112
 
 
2113
  if (previous_error)
 
2114
    return previous_error;
 
2115
 
1947
2116
  if (advance_cursor)
1948
2117
    err= ib_cursor_next(cursor);
1949
2118
 
1964
2133
  err= ib_cursor_reset(cursor);
1965
2134
  assert(err == DB_SUCCESS);
1966
2135
  in_table_scan= false;
 
2136
  previous_error= 0;
1967
2137
  return 0;
1968
2138
}
1969
2139
 
1981
2151
  }
1982
2152
  else
1983
2153
  {
 
2154
    unsigned int keynr;
 
2155
    if (table->getShare()->getPrimaryKey() != MAX_KEY)
 
2156
      keynr= table->getShare()->getPrimaryKey();
 
2157
    else
 
2158
      keynr= get_first_unique_index(*table);
 
2159
 
1984
2160
    fill_ib_search_tpl_from_drizzle_key(search_tuple,
1985
 
                                        table->key_info + 0,
 
2161
                                        table->key_info + keynr,
1986
2162
                                        pos, ref_length);
1987
2163
  }
1988
2164
 
2064
2240
 
2065
2241
void EmbeddedInnoDBCursor::position(const unsigned char *record)
2066
2242
{
2067
 
  if (table->getShare()->getPrimaryKey() != MAX_KEY)
2068
 
    store_key_value_from_innodb(table->key_info + table->getShare()->getPrimaryKey(),
 
2243
  if (share->has_hidden_primary_key)
 
2244
    *((uint64_t*) ref)= hidden_autoinc_pkey_position;
 
2245
  else
 
2246
  {
 
2247
    unsigned int keynr;
 
2248
    if (table->getShare()->getPrimaryKey() != MAX_KEY)
 
2249
      keynr= table->getShare()->getPrimaryKey();
 
2250
    else
 
2251
      keynr= get_first_unique_index(*table);
 
2252
 
 
2253
    store_key_value_from_innodb(table->key_info + keynr,
2069
2254
                                ref, ref_length, record);
2070
 
  else
2071
 
    *((uint64_t*) ref)= hidden_autoinc_pkey_position;
 
2255
  }
 
2256
 
2072
2257
  return;
2073
2258
}
2074
2259
 
2094
2279
 
2095
2280
  ib_cursor_attach_trx(cursor, transaction);
2096
2281
 
2097
 
  if (active_index == 0)
 
2282
  if (active_index == 0 && ! share->has_hidden_primary_key)
2098
2283
  {
2099
2284
    tuple= ib_clust_read_tuple_create(cursor);
2100
2285
  }
2102
2287
  {
2103
2288
    ib_err_t err;
2104
2289
    ib_id_t index_id;
2105
 
    err= ib_index_get_id(table_share->getPath()+2,
 
2290
    err= ib_index_get_id(table_path_to_innodb_name(table_share->getPath()),
2106
2291
                         table_share->getKeyInfo(keynr).name,
2107
2292
                         &index_id);
2108
2293
    if (err != DB_SUCCESS)
2109
2294
      return -1;
2110
2295
 
2111
2296
    err= ib_cursor_close(cursor);
 
2297
    assert(err == DB_SUCCESS);
2112
2298
    err= ib_cursor_open_index_using_id(index_id, transaction, &cursor);
2113
2299
 
2114
2300
    if (err != DB_SUCCESS)
2118
2304
    ib_cursor_set_cluster_access(cursor);
2119
2305
  }
2120
2306
 
 
2307
  ib_err_t err= ib_cursor_set_lock_mode(cursor, ib_lock_mode);
 
2308
  assert(err == DB_SUCCESS);
 
2309
 
2121
2310
  advance_cursor= false;
2122
2311
  return 0;
2123
2312
}
2240
2429
 
2241
2430
  search_mode= ha_rkey_function_to_ib_srch_mode(find_flag);
2242
2431
 
2243
 
  if (active_index == 0)
 
2432
  if (active_index == 0 && ! share->has_hidden_primary_key)
2244
2433
    search_tuple= ib_clust_search_tuple_create(cursor);
2245
2434
  else
2246
2435
    search_tuple= ib_sec_search_tuple_create(cursor);
2258
2447
    return HA_ERR_KEY_NOT_FOUND;
2259
2448
  }
2260
2449
 
2261
 
  assert(err==DB_SUCCESS);
 
2450
  if (err != DB_SUCCESS)
 
2451
  {
 
2452
    return ib_err_t_to_drizzle_error(err);
 
2453
  }
2262
2454
 
2263
2455
  tuple= ib_tuple_clear(tuple);
2264
2456
  ret= read_row_from_innodb(buf, cursor, tuple, table,
2371
2563
  ib_err_t err;
2372
2564
 
2373
2565
  if (advance_cursor)
 
2566
  {
2374
2567
    err= ib_cursor_prev(cursor);
2375
 
 
2376
 
  if (active_index == 0)
2377
 
  {
2378
 
    tuple= ib_tuple_clear(tuple);
2379
 
    ret= read_row_from_innodb(buf, cursor, tuple, table,
2380
 
                              share->has_hidden_primary_key,
2381
 
                              &hidden_autoinc_pkey_position);
 
2568
    if (err != DB_SUCCESS)
 
2569
    {
 
2570
      if (err == DB_END_OF_INDEX)
 
2571
        return HA_ERR_END_OF_FILE;
 
2572
      else
 
2573
        return -1; // FIXME
 
2574
    }
2382
2575
  }
2383
2576
 
 
2577
  tuple= ib_tuple_clear(tuple);
 
2578
  ret= read_row_from_innodb(buf, cursor, tuple, table,
 
2579
                            share->has_hidden_primary_key,
 
2580
                            &hidden_autoinc_pkey_position);
 
2581
 
2384
2582
  advance_cursor= true;
2385
2583
 
2386
2584
  return ret;
2394
2592
 
2395
2593
  err= ib_cursor_first(cursor);
2396
2594
  if (err != DB_SUCCESS)
2397
 
  {
2398
 
    if (err == DB_END_OF_INDEX)
2399
 
      return HA_ERR_END_OF_FILE;
2400
 
    else
2401
 
      return -1; // FIXME
2402
 
  }
 
2595
    return ib_err_t_to_drizzle_error(err);
2403
2596
 
2404
2597
  tuple= ib_tuple_clear(tuple);
2405
2598
  ret= read_row_from_innodb(buf, cursor, tuple, table,
2419
2612
 
2420
2613
  err= ib_cursor_last(cursor);
2421
2614
  if (err != DB_SUCCESS)
2422
 
  {
2423
 
    if (err == DB_END_OF_INDEX)
2424
 
      return HA_ERR_END_OF_FILE;
2425
 
    else
2426
 
      return -1; // FIXME
2427
 
  }
 
2615
    return ib_err_t_to_drizzle_error(err);
2428
2616
 
2429
 
  if (active_index == 0)
2430
 
  {
2431
 
    tuple= ib_tuple_clear(tuple);
2432
 
    ret= read_row_from_innodb(buf, cursor, tuple, table,
2433
 
                              share->has_hidden_primary_key,
2434
 
                              &hidden_autoinc_pkey_position);
2435
 
    advance_cursor= true;
2436
 
  }
 
2617
  tuple= ib_tuple_clear(tuple);
 
2618
  ret= read_row_from_innodb(buf, cursor, tuple, table,
 
2619
                            share->has_hidden_primary_key,
 
2620
                            &hidden_autoinc_pkey_position);
 
2621
  advance_cursor= true;
2437
2622
 
2438
2623
  return ret;
2439
2624
}