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

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

MySQL数据库

开发平台：

Visual C++

handler.cpp：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* Handler-calling-functions */
  20. #ifdef USE_PRAGMA_IMPLEMENTATION
  21. #pragma implementation // gcc: Class implementation
  22. #endif
  24. #include "mysql_priv.h"
  25. #include "ha_heap.h"
  26. #include "ha_myisam.h"
  27. #include "ha_myisammrg.h"
  28. #ifdef HAVE_ISAM
  29. #include "ha_isam.h"
  30. #include "ha_isammrg.h"
  31. #endif
  32. #ifdef HAVE_BERKELEY_DB
  33. #include "ha_berkeley.h"
  34. #endif
  35. #ifdef HAVE_BLACKHOLE_DB
  36. #include "ha_blackhole.h"
  37. #endif
  38. #ifdef HAVE_EXAMPLE_DB
  39. #include "examples/ha_example.h"
  40. #endif
  41. #ifdef HAVE_ARCHIVE_DB
  42. #include "examples/ha_archive.h"
  43. #endif
  44. #ifdef HAVE_CSV_DB
  45. #include "examples/ha_tina.h"
  46. #endif
  47. #ifdef HAVE_INNOBASE_DB
  48. #include "ha_innodb.h"
  49. #endif
  50. #ifdef HAVE_NDBCLUSTER_DB
  51. #include "ha_ndbcluster.h"
  52. #endif
  53. #include <myisampack.h>
  54. #include <errno.h>
  56. /* static functions defined in this file */
  58. static int NEAR_F delete_file(const char *name,const char *ext,int extflag);
  60. ulong ha_read_count, ha_write_count, ha_delete_count, ha_update_count,
  61.       ha_read_key_count, ha_read_next_count, ha_read_prev_count,
  62.       ha_read_first_count, ha_read_last_count,
  63.       ha_commit_count, ha_rollback_count,
  64.       ha_read_rnd_count, ha_read_rnd_next_count, ha_discover_count;
  66. static SHOW_COMP_OPTION have_yes= SHOW_OPTION_YES;
  68. struct show_table_type_st sys_table_types[]=
  69. {
  70.   {"MyISAM", &have_yes,
  71.    "Default engine as of MySQL 3.23 with great performance", DB_TYPE_MYISAM},
  72.   {"HEAP", &have_yes,
  73.    "Alias for MEMORY", DB_TYPE_HEAP},
  74.   {"MEMORY", &have_yes,
  75.    "Hash based, stored in memory, useful for temporary tables", DB_TYPE_HEAP},
  76.   {"MERGE", &have_yes,
  77.    "Collection of identical MyISAM tables", DB_TYPE_MRG_MYISAM},
  78.   {"MRG_MYISAM",&have_yes,
  79.    "Alias for MERGE", DB_TYPE_MRG_MYISAM},
  80.   {"ISAM", &have_isam,
  81.    "Obsolete storage engine, now replaced by MyISAM", DB_TYPE_ISAM},
  82.   {"MRG_ISAM",  &have_isam,
  83.    "Obsolete storage engine, now replaced by MERGE", DB_TYPE_MRG_ISAM},
  84.   {"InnoDB", &have_innodb,
  85.    "Supports transactions, row-level locking, and foreign keys", DB_TYPE_INNODB},
  86.   {"INNOBASE", &have_innodb,
  87.    "Alias for INNODB", DB_TYPE_INNODB},
  88.   {"BDB", &have_berkeley_db,
  89.    "Supports transactions and page-level locking", DB_TYPE_BERKELEY_DB},
  90.   {"BERKELEYDB",&have_berkeley_db,
  91.    "Alias for BDB", DB_TYPE_BERKELEY_DB},
  92.   {"NDBCLUSTER", &have_ndbcluster,
  93.    "Clustered, fault-tolerant, memory-based tables", DB_TYPE_NDBCLUSTER},
  94.   {"NDB", &have_ndbcluster,
  95.    "Alias for NDBCLUSTER", DB_TYPE_NDBCLUSTER},
  96.   {"EXAMPLE",&have_example_db,
  97.    "Example storage engine", DB_TYPE_EXAMPLE_DB},
  98.   {"ARCHIVE",&have_archive_db,
  99.    "Archive storage engine", DB_TYPE_ARCHIVE_DB},
  100.   {"CSV",&have_csv_db,
  101.    "CSV storage engine", DB_TYPE_CSV_DB},
  102.   {"BLACKHOLE",&have_blackhole_db,
  103.    "Storage engine designed to act as null storage", DB_TYPE_BLACKHOLE_DB},
  104.   {NullS, NULL, NullS, DB_TYPE_UNKNOWN}
  105. };
  107. const char *ha_row_type[] = {
  108.   "", "FIXED", "DYNAMIC", "COMPRESSED","?","?","?"
  109. };
  111. const char *tx_isolation_names[] =
  112. { "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  113.   NullS};
  114. TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
  115.        tx_isolation_names, NULL};
  117. static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
  118. uint known_extensions_id= 0;
  120. enum db_type ha_resolve_by_name(const char *name, uint namelen)
  121. {
  122.   THD *thd=current_thd;
  123.   if (thd && !my_strcasecmp(&my_charset_latin1, name, "DEFAULT")) {
  124.     return (enum db_type) thd->variables.table_type;
  125.   }
  126.   
  127.   show_table_type_st *types;
  128.   for (types= sys_table_types; types->type; types++)
  129.   {
  130.     if (!my_strcasecmp(&my_charset_latin1, name, types->type))
  131.       return (enum db_type) types->db_type;
  132.   }
  133.   return DB_TYPE_UNKNOWN;
  134. }
  136. const char *ha_get_storage_engine(enum db_type db_type)
  137. {
  138.   show_table_type_st *types;
  139.   for (types= sys_table_types; types->type; types++)
  140.   {
  141.     if (db_type == types->db_type)
  142.       return types->type;
  143.   }
  144.   
  145.   return "none";
  146. }
  149. my_bool ha_storage_engine_is_enabled(enum db_type database_type)
  150. {
  151.   show_table_type_st *types;
  152.   for (types= sys_table_types; types->type; types++)
  153.   {
  154.     if ((database_type == types->db_type) &&
  155. (*types->value == SHOW_OPTION_YES))
  156.       return TRUE;
  157.   }
  158.   return FALSE;
  159. }
  162. /* Use other database handler if databasehandler is not incompiled */
  164. enum db_type ha_checktype(enum db_type database_type)
  165. {
  166.   if (ha_storage_engine_is_enabled(database_type))
  167.     return database_type;
  169.   switch (database_type) {
  170. #ifndef NO_HASH
  171.   case DB_TYPE_HASH:
  172.     return (database_type);
  173. #endif
  174.   case DB_TYPE_MRG_ISAM:
  175.     return (DB_TYPE_MRG_MYISAM);
  176.   default:
  177.     break;
  178.   }
  179.   
  180.   return 
  181.     DB_TYPE_UNKNOWN != (enum db_type) current_thd->variables.table_type ?
  182.     (enum db_type) current_thd->variables.table_type :
  183.     DB_TYPE_UNKNOWN != (enum db_type) global_system_variables.table_type ?
  184.     (enum db_type) global_system_variables.table_type :
  185.     DB_TYPE_MYISAM;
  186. } /* ha_checktype */
  189. handler *get_new_handler(TABLE *table, enum db_type db_type)
  190. {
  191.   switch (db_type) {
  192. #ifndef NO_HASH
  193.   case DB_TYPE_HASH:
  194.     return new ha_hash(table);
  195. #endif
  196. #ifdef HAVE_ISAM
  197.   case DB_TYPE_MRG_ISAM:
  198.     return new ha_isammrg(table);
  199.   case DB_TYPE_ISAM:
  200.     return new ha_isam(table);
  201. #else
  202.   case DB_TYPE_MRG_ISAM:
  203.     return new ha_myisammrg(table);
  204. #endif
  205. #ifdef HAVE_BERKELEY_DB
  206.   case DB_TYPE_BERKELEY_DB:
  207.     return new ha_berkeley(table);
  208. #endif
  209. #ifdef HAVE_INNOBASE_DB
  210.   case DB_TYPE_INNODB:
  211.     return new ha_innobase(table);
  212. #endif
  213. #ifdef HAVE_EXAMPLE_DB
  214.   case DB_TYPE_EXAMPLE_DB:
  215.     return new ha_example(table);
  216. #endif
  217. #ifdef HAVE_ARCHIVE_DB
  218.   case DB_TYPE_ARCHIVE_DB:
  219.     return new ha_archive(table);
  220. #endif
  221. #ifdef HAVE_BLACKHOLE_DB
  222.   case DB_TYPE_BLACKHOLE_DB:
  223.     return new ha_blackhole(table);
  224. #endif
  225. #ifdef HAVE_CSV_DB
  226.   case DB_TYPE_CSV_DB:
  227.     return new ha_tina(table);
  228. #endif
  229. #ifdef HAVE_NDBCLUSTER_DB
  230.   case DB_TYPE_NDBCLUSTER:
  231.     return new ha_ndbcluster(table);
  232. #endif
  233.   case DB_TYPE_HEAP:
  234.     return new ha_heap(table);
  235.   default: // should never happen
  236.   {
  237.     enum db_type def=(enum db_type) current_thd->variables.table_type;
  238.     /* Try first with 'default table type' */
  239.     if (db_type != def)
  240.       return get_new_handler(table, def);
  241.   }
  242.   /* Fall back to MyISAM */
  243.   case DB_TYPE_MYISAM:
  244.     return new ha_myisam(table);
  245.   case DB_TYPE_MRG_MYISAM:
  246.     return new ha_myisammrg(table);
  247.   }
  248. }
  250. bool ha_caching_allowed(THD* thd, char* table_key,
  251.                         uint key_length, uint8 cache_type)
  252. {
  253. #ifdef HAVE_INNOBASE_DB
  254.   if (cache_type == HA_CACHE_TBL_ASKTRANSACT)
  255.     return innobase_query_caching_of_table_permitted(thd, table_key, key_length);
  256. #endif
  257.   return 1;
  258. }
  260. int ha_init()
  261. {
  262.   int error= 0;
  263. #ifdef HAVE_BERKELEY_DB
  264.   if (have_berkeley_db == SHOW_OPTION_YES)
  265.   {
  266.     if (berkeley_init())
  267.     {
  268.       have_berkeley_db= SHOW_OPTION_DISABLED; // If we couldn't use handler
  269.       error= 1;
  270.     }
  271.     else
  272.       opt_using_transactions=1;
  273.   }
  274. #endif
  275. #ifdef HAVE_INNOBASE_DB
  276.   if (have_innodb == SHOW_OPTION_YES)
  277.   {
  278.     if (innobase_init())
  279.     {
  280.       have_innodb= SHOW_OPTION_DISABLED; // If we couldn't use handler
  281.       error= 1;
  282.     }
  283.     else
  284.       opt_using_transactions=1;
  285.   }
  286. #endif
  287. #ifdef HAVE_NDBCLUSTER_DB
  288.   if (have_ndbcluster == SHOW_OPTION_YES)
  289.   {
  290.     if (ndbcluster_init())
  291.     {
  292.       have_ndbcluster= SHOW_OPTION_DISABLED;
  293.       error= 1;
  294.     }
  295.     else
  296.       opt_using_transactions=1;
  297.   }
  298. #endif
  299. #ifdef HAVE_ARCHIVE_DB
  300.   if (have_archive_db == SHOW_OPTION_YES)
  301.   {
  302.     if (archive_db_init())
  303.     {
  304.       have_archive_db= SHOW_OPTION_DISABLED;
  305.       error= 1;
  306.     }
  307.   }
  308. #endif
  309.   return error;
  310. }
  312. /* close, flush or restart databases */
  313. /* Ignore this for other databases than ours */
  315. int ha_panic(enum ha_panic_function flag)
  316. {
  317.   int error=0;
  318. #ifndef NO_HASH
  319.   error|=h_panic(flag); /* fix hash */
  320. #endif
  321. #ifdef HAVE_ISAM
  322.   error|=mrg_panic(flag);
  323.   error|=nisam_panic(flag);
  324. #endif
  325.   error|=heap_panic(flag);
  326.   error|=mi_panic(flag);
  327.   error|=myrg_panic(flag);
  328. #ifdef HAVE_BERKELEY_DB
  329.   if (have_berkeley_db == SHOW_OPTION_YES)
  330.     error|=berkeley_end();
  331. #endif
  332. #ifdef HAVE_INNOBASE_DB
  333.   if (have_innodb == SHOW_OPTION_YES)
  334.     error|=innobase_end();
  335. #endif
  336. #ifdef HAVE_NDBCLUSTER_DB
  337.   if (have_ndbcluster == SHOW_OPTION_YES)
  338.     error|=ndbcluster_end();
  339. #endif
  340. #ifdef HAVE_ARCHIVE_DB
  341.   if (have_archive_db == SHOW_OPTION_YES)
  342.     error|= archive_db_end();
  343. #endif
  344.   return error;
  345. } /* ha_panic */
  347. void ha_drop_database(char* path)
  348. {
  349. #ifdef HAVE_INNOBASE_DB
  350.   if (have_innodb == SHOW_OPTION_YES)
  351.     innobase_drop_database(path);
  352. #endif
  353. #ifdef HAVE_NDBCLUSTER_DB
  354.   if (have_ndbcluster == SHOW_OPTION_YES)
  355.     ndbcluster_drop_database(path);
  356. #endif
  357. }
  359. void ha_close_connection(THD* thd)
  360. {
  361. #ifdef HAVE_INNOBASE_DB
  362.   if (have_innodb == SHOW_OPTION_YES)
  363.     innobase_close_connection(thd);
  364. #endif
  365. #ifdef HAVE_NDBCLUSTER_DB
  366.   if (have_ndbcluster == SHOW_OPTION_YES)
  367.     ndbcluster_close_connection(thd);
  368. #endif
  369. }
  371. /*
  372.   This is used to commit or rollback a single statement depending on the value
  373.   of error. Note that if the autocommit is on, then the following call inside
  374.   InnoDB will commit or rollback the whole transaction (= the statement). The
  375.   autocommit mechanism built into InnoDB is based on counting locks, but if
  376.   the user has used LOCK TABLES then that mechanism does not know to do the
  377.   commit.
  378. */
  380. int ha_autocommit_or_rollback(THD *thd, int error)
  381. {
  382.   DBUG_ENTER("ha_autocommit_or_rollback");
  383. #ifdef USING_TRANSACTIONS
  384.   if (opt_using_transactions)
  385.   {
  386.     if (!error)
  387.     {
  388.       if (ha_commit_stmt(thd))
  389. error=1;
  390.     }
  391.     else
  392.       (void) ha_rollback_stmt(thd);
  394.     thd->variables.tx_isolation=thd->session_tx_isolation;
  395.   }
  396. #endif
  397.   DBUG_RETURN(error);
  398. }
  400. /*
  401.   This function is called when MySQL writes the log segment of a
  402.   transaction to the binlog. It is called when the LOCK_log mutex is
  403.   reserved. Here we communicate to transactional table handlers what
  404.   binlog position corresponds to the current transaction. The handler
  405.   can store it and in recovery print to the user, so that the user
  406.   knows from what position in the binlog to start possible
  407.   roll-forward, for example, if the crashed server was a slave in
  408.   replication. This function also calls the commit of the table
  409.   handler, because the order of transactions in the log of the table
  410.   handler must be the same as in the binlog.
  411.   NOTE that to eliminate the bottleneck of the group commit, we do not
  412.   flush the handler log files here, but only later in a call of
  413.   ha_commit_complete().
  415.   arguments:
  416.   thd:           the thread handle of the current connection
  417.   log_file_name: latest binlog file name
  418.   end_offset:  the offset in the binlog file up to which we wrote
  419.   return value:  0 if success, 1 if error
  420. */
  422. int ha_report_binlog_offset_and_commit(THD *thd,
  423.        char *log_file_name,
  424.        my_off_t end_offset)
  425. {
  426.   int  error= 0;
  427. #ifdef HAVE_INNOBASE_DB
  428.   THD_TRANS *trans;
  429.   trans = &thd->transaction.all;
  430.   if (trans->innodb_active_trans)
  431.   {
  432.     /*
  433.       If we updated some InnoDB tables (innodb_active_trans is true), the
  434.       binlog coords will be reported into InnoDB during the InnoDB commit
  435.       (innobase_report_binlog_offset_and_commit). But if we updated only
  436.       non-InnoDB tables, we need an explicit call to report it.
  437.     */
  438.     if ((error=innobase_report_binlog_offset_and_commit(thd,
  439.                                                         trans->innobase_tid,
  440.                                                         log_file_name,
  441.                                                         end_offset)))
  442.     {
  443.       my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
  444.       error=1;
  445.     }
  446.   }
  447.   else if (opt_innodb_safe_binlog) // Don't report if not useful
  448.     innobase_store_binlog_offset_and_flush_log(log_file_name, end_offset);
  449. #endif
  450.   return error;
  451. }
  453. /*
  454.   Flushes the handler log files (if my.cnf settings do not free us from it)
  455.   after we have called ha_report_binlog_offset_and_commit(). To eliminate
  456.   the bottleneck from the group commit, this should be called when
  457.   LOCK_log has been released in log.cc.
  459.   arguments:
  460.   thd:           the thread handle of the current connection
  461.   return value:  always 0
  462. */
  464. int ha_commit_complete(THD *thd)
  465. {
  466. #ifdef HAVE_INNOBASE_DB
  467.   THD_TRANS *trans;
  468.   trans = &thd->transaction.all;
  469.   if (trans->innobase_tid)
  470.   {
  471.     innobase_commit_complete(trans->innobase_tid);
  473.     trans->innodb_active_trans=0;
  474.   }
  475. #endif
  476.   return 0;
  477. }
  479. /*
  480.   This function should be called when MySQL sends rows of a SELECT result set
  481.   or the EOF mark to the client. It releases a possible adaptive hash index
  482.   S-latch held by thd in InnoDB and also releases a possible InnoDB query
  483.   FIFO ticket to enter InnoDB. To save CPU time, InnoDB allows a thd to
  484.   keep them over several calls of the InnoDB handler interface when a join
  485.   is executed. But when we let the control to pass to the client they have
  486.   to be released because if the application program uses mysql_use_result(),
  487.   it may deadlock on the S-latch if the application on another connection
  488.   performs another SQL query. In MySQL-4.1 this is even more important because
  489.   there a connection can have several SELECT queries open at the same time.
  491.   arguments:
  492.   thd:           the thread handle of the current connection
  493.   return value:  always 0
  494. */
  496. int ha_release_temporary_latches(THD *thd)
  497. {
  498. #ifdef HAVE_INNOBASE_DB
  499.   THD_TRANS *trans;
  500.   trans = &thd->transaction.all;
  501.   if (trans->innobase_tid)
  502.     innobase_release_temporary_latches(trans->innobase_tid);
  503. #endif
  504.   return 0;
  505. }
  507. int ha_commit_trans(THD *thd, THD_TRANS* trans)
  508. {
  509.   int error=0;
  510.   DBUG_ENTER("ha_commit_trans");
  511. #ifdef USING_TRANSACTIONS
  512.   if (opt_using_transactions)
  513.   {
  514.     bool transaction_commited= 0;
  515.     bool operation_done= 0, need_start_waiters= 0;
  517.     /* If transaction has done some updates to tables */
  518.     if (trans == &thd->transaction.all && mysql_bin_log.is_open() &&
  519.         my_b_tell(&thd->transaction.trans_log))
  520.     {
  521.       if ((error= wait_if_global_read_lock(thd, 0, 0)))
  522.       {
  523.         /*
  524.           Note that ROLLBACK [TO SAVEPOINT] does not have this test; it's
  525.           because ROLLBACK never updates data, so needn't wait on the lock.
  526.         */
  527.         my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
  528.         error= 1;
  529.       }
  530.       else
  531.         need_start_waiters= 1;
  532.       if (mysql_bin_log.is_open())
  533.       {
  534.         mysql_bin_log.write(thd, &thd->transaction.trans_log, 1);
  535.         statistic_increment(binlog_cache_use, &LOCK_status);
  536.         if (thd->transaction.trans_log.disk_writes != 0)
  537.         {
  538.           /* 
  539.             We have to do this after addition of trans_log to main binlog since
  540.             this operation can cause flushing of end of trans_log to disk. 
  541.           */
  542.           statistic_increment(binlog_cache_disk_use, &LOCK_status);
  543.           thd->transaction.trans_log.disk_writes= 0;
  544.         }
  545.         reinit_io_cache(&thd->transaction.trans_log,
  546.                         WRITE_CACHE, (my_off_t) 0, 0, 1);
  547.         thd->transaction.trans_log.end_of_file= max_binlog_cache_size;
  548.       }
  549.     }
  550. #ifdef HAVE_NDBCLUSTER_DB
  551.     if (trans->ndb_tid)
  552.     {
  553.       if ((error=ndbcluster_commit(thd,trans->ndb_tid)))
  554.       {
  555. if (error == -1)
  556.   my_error(ER_ERROR_DURING_COMMIT, MYF(0));
  557.         error=1;
  558.       }
  559.       if (trans == &thd->transaction.all)
  560.         operation_done= transaction_commited= 1;
  561.       trans->ndb_tid=0;
  562.     }
  563. #endif
  564. #ifdef HAVE_BERKELEY_DB
  565.     if (trans->bdb_tid)
  566.     {
  567.       if ((error=berkeley_commit(thd,trans->bdb_tid)))
  568.       {
  569. my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
  570. error=1;
  571.       }
  572.       else
  573. if (!(thd->options & OPTION_BEGIN))
  574.   transaction_commited= 1; 
  575.       trans->bdb_tid=0;
  576.     }
  577. #endif
  578. #ifdef HAVE_INNOBASE_DB
  579.     if (trans->innobase_tid)
  580.     {
  581.       if ((error=innobase_commit(thd,trans->innobase_tid)))
  582.       {
  583. my_error(ER_ERROR_DURING_COMMIT, MYF(0), error);
  584. error=1;
  585.       }
  586.       trans->innodb_active_trans=0;
  587.       if (trans == &thd->transaction.all)
  588. operation_done= transaction_commited= 1;
  589.     }
  590. #endif
  591. #ifdef HAVE_QUERY_CACHE
  592.     if (transaction_commited && thd->transaction.changed_tables)
  593.       query_cache.invalidate(thd->transaction.changed_tables);
  594. #endif /*HAVE_QUERY_CACHE*/
  595.     if (error && trans == &thd->transaction.all && mysql_bin_log.is_open())
  596.       sql_print_error("Got error during commit;  Binlog is not up to date!");
  597.     thd->variables.tx_isolation=thd->session_tx_isolation;
  598.     if (operation_done)
  599.     {
  600.       statistic_increment(ha_commit_count,&LOCK_status);
  601.       thd->transaction.cleanup();
  602.     }
  603.     if (need_start_waiters)
  604.       start_waiting_global_read_lock(thd);
  605.   }
  606. #endif // using transactions
  607.   DBUG_RETURN(error);
  608. }
  611. int ha_rollback_trans(THD *thd, THD_TRANS *trans)
  612. {
  613.   int error=0;
  614.   DBUG_ENTER("ha_rollback_trans");
  615. #ifdef USING_TRANSACTIONS
  616.   if (opt_using_transactions)
  617.   {
  618.     bool operation_done=0;
  619.     /*
  620.       As rollback can be 30 times slower than insert in InnoDB, and user may
  621.       not know there's rollback (if it's because of a dupl row), better warn.
  622.     */
  623.     const char *save_proc_info= thd->proc_info;
  624.     thd->proc_info= "Rolling back";
  625. #ifdef HAVE_NDBCLUSTER_DB
  626.     if (trans->ndb_tid)
  627.     {
  628.       if ((error=ndbcluster_rollback(thd, trans->ndb_tid)))
  629.       {
  630. if (error == -1)
  631.   my_error(ER_ERROR_DURING_ROLLBACK, MYF(0));
  632.         error=1;
  633.       }
  634.       trans->ndb_tid = 0;
  635.       operation_done=1;
  636.     }
  637. #endif
  638. #ifdef HAVE_BERKELEY_DB
  639.     if (trans->bdb_tid)
  640.     {
  641.       if ((error=berkeley_rollback(thd, trans->bdb_tid)))
  642.       {
  643. my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
  644. error=1;
  645.       }
  646.       trans->bdb_tid=0;
  647.       operation_done=1;
  648.     }
  649. #endif
  650. #ifdef HAVE_INNOBASE_DB
  651.     if (trans->innobase_tid)
  652.     {
  653.       if ((error=innobase_rollback(thd, trans->innobase_tid)))
  654.       {
  655. my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
  656. error=1;
  657.       }
  658.       trans->innodb_active_trans=0;
  659.       operation_done=1;
  660.     }
  661. #endif
  662.     if ((trans == &thd->transaction.all) && mysql_bin_log.is_open())
  663.     {
  664.       /* 
  665.          Update the binary log with a BEGIN/ROLLBACK block if we have
  666.          cached some queries and we updated some non-transactional
  667.          table. Such cases should be rare (updating a
  668.          non-transactional table inside a transaction...).  Count disk
  669.          writes to trans_log in any case.
  670.       */
  671.       if (my_b_tell(&thd->transaction.trans_log))
  672.       {
  673.         if (unlikely(thd->options & OPTION_STATUS_NO_TRANS_UPDATE))
  674.           mysql_bin_log.write(thd, &thd->transaction.trans_log, 0);
  675.         statistic_increment(binlog_cache_use, &LOCK_status);
  676.         if (thd->transaction.trans_log.disk_writes != 0)
  677.         {
  678.           /* 
  679.             We have to do this after addition of trans_log to main binlog since
  680.             this operation can cause flushing of end of trans_log to disk. 
  681.           */
  682.           statistic_increment(binlog_cache_disk_use, &LOCK_status);
  683.           thd->transaction.trans_log.disk_writes= 0;
  684.         }
  685.       }
  686.       /* Flushed or not, empty the binlog cache */
  687.       reinit_io_cache(&thd->transaction.trans_log,
  688.                       WRITE_CACHE, (my_off_t) 0, 0, 1);
  689.       thd->transaction.trans_log.end_of_file= max_binlog_cache_size;
  690.       if (operation_done)
  691.         thd->transaction.cleanup();
  692.     }
  693.     thd->variables.tx_isolation=thd->session_tx_isolation;
  694.     if (operation_done)
  695.       statistic_increment(ha_rollback_count,&LOCK_status);
  696.     thd->proc_info= save_proc_info;
  697.   }
  698. #endif /* USING_TRANSACTIONS */
  699.   DBUG_RETURN(error);
  700. }
  703. /*
  704.   Rolls the current transaction back to a savepoint.
  705.   Return value: 0 if success, 1 if there was not a savepoint of the given
  706.   name.
  707.   NOTE: how do we handle this (unlikely but legal) case:
  708.   [transaction] + [update to non-trans table] + [rollback to savepoint] ?
  709.   The problem occurs when a savepoint is before the update to the
  710.   non-transactional table. Then when there's a rollback to the savepoint, if we
  711.   simply truncate the binlog cache, we lose the part of the binlog cache where
  712.   the update is. If we want to not lose it, we need to write the SAVEPOINT
  713.   command and the ROLLBACK TO SAVEPOINT command to the binlog cache. The latter
  714.   is easy: it's just write at the end of the binlog cache, but the former
  715.   should be *inserted* to the place where the user called SAVEPOINT. The
  716.   solution is that when the user calls SAVEPOINT, we write it to the binlog
  717.   cache (so no need to later insert it). As transactions are never intermixed
  718.   in the binary log (i.e. they are serialized), we won't have conflicts with
  719.   savepoint names when using mysqlbinlog or in the slave SQL thread.
  720.   Then when ROLLBACK TO SAVEPOINT is called, if we updated some
  721.   non-transactional table, we don't truncate the binlog cache but instead write
  722.   ROLLBACK TO SAVEPOINT to it; otherwise we truncate the binlog cache (which
  723.   will chop the SAVEPOINT command from the binlog cache, which is good as in
  724.   that case there is no need to have it in the binlog).
  725. */
  727. int ha_rollback_to_savepoint(THD *thd, char *savepoint_name)
  728. {
  729.   my_off_t binlog_cache_pos=0;
  730.   bool operation_done=0;
  731.   int error=0;
  732.   DBUG_ENTER("ha_rollback_to_savepoint");
  733. #ifdef USING_TRANSACTIONS
  734.   if (opt_using_transactions)
  735.   {
  736. #ifdef HAVE_INNOBASE_DB
  737.     /*
  738.     Retrieve the trans_log binlog cache position corresponding to the
  739.     savepoint, and if the rollback is successful inside InnoDB reset the write
  740.     position in the binlog cache to what it was at the savepoint.
  741.     */
  742.     if ((error=innobase_rollback_to_savepoint(thd, savepoint_name,
  743.   &binlog_cache_pos)))
  744.     {
  745.       my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), error);
  746.       error=1;
  747.     }
  748.     else if (mysql_bin_log.is_open())
  749.     {
  750.       /* 
  751.          Write ROLLBACK TO SAVEPOINT to the binlog cache if we have updated some
  752.          non-transactional table. Otherwise, truncate the binlog cache starting
  753.          from the SAVEPOINT command.
  754.       */
  755.       if (unlikely((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) &&
  756.                    my_b_tell(&thd->transaction.trans_log)))
  757.       {
  758.         Query_log_event qinfo(thd, thd->query, thd->query_length, TRUE, FALSE);
  759.         if (mysql_bin_log.write(&qinfo))
  760.           error= 1;
  761.       }
  762.       else
  763.         reinit_io_cache(&thd->transaction.trans_log, WRITE_CACHE,
  764.                         binlog_cache_pos, 0, 0);
  765.     }
  766.     operation_done=1;
  767. #endif
  768.     if (operation_done)
  769.       statistic_increment(ha_rollback_count,&LOCK_status);
  770.   }
  771. #endif /* USING_TRANSACTIONS */
  773.   DBUG_RETURN(error);
  774. }
  777. /*
  778. Sets a transaction savepoint.
  779. Return value: always 0, that is, succeeds always
  780. */
  782. int ha_savepoint(THD *thd, char *savepoint_name)
  783. {
  784.   int error=0;
  785.   DBUG_ENTER("ha_savepoint");
  786. #ifdef USING_TRANSACTIONS
  787.   if (opt_using_transactions)
  788.   {
  789.     /* Write it to the binary log (see comments of ha_rollback_to_savepoint) */
  790.     if (mysql_bin_log.is_open())
  791.     {
  792. #ifdef HAVE_INNOBASE_DB
  793.       innobase_savepoint(thd,savepoint_name,
  794.                          my_b_tell(&thd->transaction.trans_log));
  795. #endif
  796.       Query_log_event qinfo(thd, thd->query, thd->query_length, TRUE, FALSE);
  797.       if (mysql_bin_log.write(&qinfo))
  798. error= 1;
  799.     }
  800. #ifdef HAVE_INNOBASE_DB
  801.     else
  802.       innobase_savepoint(thd,savepoint_name,0);
  803. #endif
  804.   }
  805. #endif /* USING_TRANSACTIONS */
  806.   DBUG_RETURN(error);
  807. }
  810. int ha_start_consistent_snapshot(THD *thd)
  811. {
  812. #ifdef HAVE_INNOBASE_DB
  813.   if ((have_innodb == SHOW_OPTION_YES) &&
  814.       !innobase_start_trx_and_assign_read_view(thd))
  815.     return 0;
  816. #endif
  817.   /*
  818.     Same idea as when one wants to CREATE TABLE in one engine which does not
  819.     exist:
  820.   */
  821.   push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
  822.                "This MySQL server does not support any "
  823.                "consistent-read capable storage engine");
  824.   return 0;
  825. }
  828. bool ha_flush_logs()
  829. {
  830.   bool result=0;
  831. #ifdef HAVE_BERKELEY_DB
  832.   if ((have_berkeley_db == SHOW_OPTION_YES) &&
  833.       berkeley_flush_logs())
  834.     result=1;
  835. #endif
  836. #ifdef HAVE_INNOBASE_DB
  837.   if ((have_innodb == SHOW_OPTION_YES) &&
  838.       innobase_flush_logs())
  839.     result=1;
  840. #endif
  841.   return result;
  842. }
  844. /*
  845.   This should return ENOENT if the file doesn't exists.
  846.   The .frm file will be deleted only if we return 0 or ENOENT
  847. */
  849. int ha_delete_table(enum db_type table_type, const char *path)
  850. {
  851.   char tmp_path[FN_REFLEN];
  852.   handler *file=get_new_handler((TABLE*) 0, table_type);
  853.   if (!file)
  854.     return ENOENT;
  855.   if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  856.   {
  857.     /* Ensure that table handler get path in lower case */
  858.     strmov(tmp_path, path);
  859.     my_casedn_str(files_charset_info, tmp_path);
  860.     path= tmp_path;
  861.   }
  862.   int error=file->delete_table(path);
  863.   delete file;
  864.   return error;
  865. }
  868. void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos)
  869. {
  870.   switch (pack_length) {
  871. #if SIZEOF_OFF_T > 4
  872.   case 8: mi_int8store(buff,pos); break;
  873.   case 7: mi_int7store(buff,pos); break;
  874.   case 6: mi_int6store(buff,pos); break;
  875.   case 5: mi_int5store(buff,pos); break;
  876. #endif
  877.   case 4: mi_int4store(buff,pos); break;
  878.   case 3: mi_int3store(buff,pos); break;
  879.   case 2: mi_int2store(buff,(uint) pos); break;
  880.   case 1: buff[0]= (uchar) pos; break;
  881.   }
  882.   return;
  883. }
  885. my_off_t ha_get_ptr(byte *ptr, uint pack_length)
  886. {
  887.   my_off_t pos;
  888.   switch (pack_length) {
  889. #if SIZEOF_OFF_T > 4
  890.   case 8:
  891.     pos= (my_off_t) mi_uint8korr(ptr);
  892.     break;
  893.   case 7:
  894.     pos= (my_off_t) mi_uint7korr(ptr);
  895.     break;
  896.   case 6:
  897.     pos= (my_off_t) mi_uint6korr(ptr);
  898.     break;
  899.   case 5:
  900.     pos= (my_off_t) mi_uint5korr(ptr);
  901.     break;
  902. #endif
  903.   case 4:
  904.     pos= (my_off_t) mi_uint4korr(ptr);
  905.     break;
  906.   case 3:
  907.     pos= (my_off_t) mi_uint3korr(ptr);
  908.     break;
  909.   case 2:
  910.     pos= (my_off_t) mi_uint2korr(ptr);
  911.     break;
  912.   case 1:
  913.     pos= (my_off_t) mi_uint2korr(ptr);
  914.     break;
  915.   default:
  916.     pos=0; // Impossible
  917.     break;
  918.   }
  919.  return pos;
  920. }
  922. /****************************************************************************
  923. ** General handler functions
  924. ****************************************************************************/
  926. /* Open database-handler. Try O_RDONLY if can't open as O_RDWR */
  927. /* Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set */
  929. int handler::ha_open(const char *name, int mode, int test_if_locked)
  930. {
  931.   int error;
  932.   DBUG_ENTER("handler::ha_open");
  933.   DBUG_PRINT("enter",("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
  934.       name, table->db_type, table->db_stat, mode,
  935.       test_if_locked));
  937.   if ((error=open(name,mode,test_if_locked)))
  938.   {
  939.     if ((error == EACCES || error == EROFS) && mode == O_RDWR &&
  940. (table->db_stat & HA_TRY_READ_ONLY))
  941.     {
  942.       table->db_stat|=HA_READ_ONLY;
  943.       error=open(name,O_RDONLY,test_if_locked);
  944.     }
  945.   }
  946.   if (error)
  947.   {
  948.     my_errno=error; /* Safeguard */
  949.     DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  950.   }
  951.   else
  952.   {
  953.     if (table->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
  954.       table->db_stat|=HA_READ_ONLY;
  955.     (void) extra(HA_EXTRA_NO_READCHECK); // Not needed in SQL
  957.     if (!alloc_root_inited(&table->mem_root)) // If temporary table
  958.       ref=(byte*) sql_alloc(ALIGN_SIZE(ref_length)*2);
  959.     else
  960.       ref=(byte*) alloc_root(&table->mem_root, ALIGN_SIZE(ref_length)*2);
  961.     if (!ref)
  962.     {
  963.       close();
  964.       error=HA_ERR_OUT_OF_MEM;
  965.     }
  966.     else
  967.       dupp_ref=ref+ALIGN_SIZE(ref_length);
  968.   }
  969.   DBUG_RETURN(error);
  970. }
  972. /*
  973.   Read first row (only) from a table
  974.   This is never called for InnoDB or BDB tables, as these table types
  975.   has the HA_NOT_EXACT_COUNT set.
  976. */
  978. int handler::read_first_row(byte * buf, uint primary_key)
  979. {
  980.   register int error;
  981.   DBUG_ENTER("handler::read_first_row");
  983.   statistic_increment(ha_read_first_count,&LOCK_status);
  985.   /*
  986.     If there is very few deleted rows in the table, find the first row by
  987.     scanning the table.
  988.     TODO remove the test for HA_READ_ORDER
  989.   */
  990.   if (deleted < 10 || primary_key >= MAX_KEY ||
  991.       !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
  992.   {
  993.     (void) ha_rnd_init(1);
  994.     while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
  995.     (void) ha_rnd_end();
  996.   }
  997.   else
  998.   {
  999.     /* Find the first row through the primary key */
  1000.     (void) ha_index_init(primary_key);
  1001.     error=index_first(buf);
  1002.     (void) ha_index_end();
  1003.   }
  1004.   DBUG_RETURN(error);
  1005. }
  1008. /*
  1009.   Updates field with field_type NEXT_NUMBER according to following:
  1010.   if field = 0 change field to the next free key in database.
  1011. */
  1013. void handler::update_auto_increment()
  1014. {
  1015.   longlong nr;
  1016.   THD *thd;
  1017.   DBUG_ENTER("handler::update_auto_increment");
  1018.   if (table->next_number_field->val_int() != 0 ||
  1019.       table->auto_increment_field_not_null &&
  1020.       current_thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
  1021.   {
  1022.     table->auto_increment_field_not_null= FALSE;
  1023.     auto_increment_column_changed=0;
  1024.     DBUG_VOID_RETURN;
  1025.   }
  1026.   table->auto_increment_field_not_null= FALSE;
  1027.   thd=current_thd;
  1028.   if ((nr=thd->next_insert_id))
  1029.     thd->next_insert_id=0; // Clear after use
  1030.   else
  1031.     nr=get_auto_increment();
  1032.   if (!table->next_number_field->store(nr))
  1033.     thd->insert_id((ulonglong) nr);
  1034.   else
  1035.     thd->insert_id(table->next_number_field->val_int());
  1036.   auto_increment_column_changed=1;
  1037.   DBUG_VOID_RETURN;
  1038. }
  1041. longlong handler::get_auto_increment()
  1042. {
  1043.   longlong nr;
  1044.   int error;
  1046.   (void) extra(HA_EXTRA_KEYREAD);
  1047.   index_init(table->next_number_index);
  1048.   if (!table->next_number_key_offset)
  1049.   { // Autoincrement at key-start
  1050.     error=index_last(table->record[1]);
  1051.   }
  1052.   else
  1053.   {
  1054.     byte key[MAX_KEY_LENGTH];
  1055.     key_copy(key,table,table->next_number_index,
  1056.              table->next_number_key_offset);
  1057.     error=index_read(table->record[1], key, table->next_number_key_offset,
  1058.                      HA_READ_PREFIX_LAST);
  1059.   }
  1061.   if (error)
  1062.     nr=1;
  1063.   else
  1064.     nr=(longlong) table->next_number_field->
  1065.       val_int_offset(table->rec_buff_length)+1;
  1066.   index_end();
  1067.   (void) extra(HA_EXTRA_NO_KEYREAD);
  1068.   return nr;
  1069. }
  1071. /* Print error that we got from handler function */
  1073. void handler::print_error(int error, myf errflag)
  1074. {
  1075.   DBUG_ENTER("handler::print_error");
  1076.   DBUG_PRINT("enter",("error: %d",error));
  1078.   int textno=ER_GET_ERRNO;
  1079.   switch (error) {
  1080.   case EACCES:
  1081.     textno=ER_OPEN_AS_READONLY;
  1082.     break;
  1083.   case EAGAIN:
  1084.     textno=ER_FILE_USED;
  1085.     break;
  1086.   case ENOENT:
  1087.     textno=ER_FILE_NOT_FOUND;
  1088.     break;
  1089.   case HA_ERR_KEY_NOT_FOUND:
  1090.   case HA_ERR_NO_ACTIVE_RECORD:
  1091.   case HA_ERR_END_OF_FILE:
  1092.     textno=ER_KEY_NOT_FOUND;
  1093.     break;
  1094.   case HA_ERR_WRONG_MRG_TABLE_DEF:
  1095.     textno=ER_WRONG_MRG_TABLE;
  1096.     break;
  1097.   case HA_ERR_FOUND_DUPP_KEY:
  1098.   {
  1099.     uint key_nr=get_dup_key(error);
  1100.     if ((int) key_nr >= 0)
  1101.     {
  1102.       /* Write the dupplicated key in the error message */
  1103.       char key[MAX_KEY_LENGTH];
  1104.       String str(key,sizeof(key),system_charset_info);
  1105.       key_unpack(&str,table,(uint) key_nr);
  1106.       uint max_length=MYSQL_ERRMSG_SIZE-(uint) strlen(ER(ER_DUP_ENTRY));
  1107.       if (str.length() >= max_length)
  1108.       {
  1109. str.length(max_length-4);
  1110. str.append("...");
  1111.       }
  1112.       my_error(ER_DUP_ENTRY,MYF(0),str.c_ptr(),key_nr+1);
  1113.       DBUG_VOID_RETURN;
  1114.     }
  1115.     textno=ER_DUP_KEY;
  1116.     break;
  1117.   }
  1118.   case HA_ERR_NULL_IN_SPATIAL:
  1119.     textno= ER_UNKNOWN_ERROR;
  1120.     DBUG_VOID_RETURN;
  1121.   case HA_ERR_FOUND_DUPP_UNIQUE:
  1122.     textno=ER_DUP_UNIQUE;
  1123.     break;
  1124.   case HA_ERR_RECORD_CHANGED:
  1125.     textno=ER_CHECKREAD;
  1126.     break;
  1127.   case HA_ERR_CRASHED:
  1128.     textno=ER_NOT_KEYFILE;
  1129.     break;
  1130.   case HA_ERR_CRASHED_ON_USAGE:
  1131.     textno=ER_CRASHED_ON_USAGE;
  1132.     break;
  1133.   case HA_ERR_CRASHED_ON_REPAIR:
  1134.     textno=ER_CRASHED_ON_REPAIR;
  1135.     break;
  1136.   case HA_ERR_OUT_OF_MEM:
  1137.     my_error(ER_OUT_OF_RESOURCES,errflag);
  1138.     DBUG_VOID_RETURN;
  1139.   case HA_ERR_WRONG_COMMAND:
  1140.     textno=ER_ILLEGAL_HA;
  1141.     break;
  1142.   case HA_ERR_OLD_FILE:
  1143.     textno=ER_OLD_KEYFILE;
  1144.     break;
  1145.   case HA_ERR_UNSUPPORTED:
  1146.     textno=ER_UNSUPPORTED_EXTENSION;
  1147.     break;
  1148.   case HA_ERR_RECORD_FILE_FULL:
  1149.     textno=ER_RECORD_FILE_FULL;
  1150.     break;
  1151.   case HA_ERR_LOCK_WAIT_TIMEOUT:
  1152.     textno=ER_LOCK_WAIT_TIMEOUT;
  1153.     break;
  1154.   case HA_ERR_LOCK_TABLE_FULL:
  1155.     textno=ER_LOCK_TABLE_FULL;
  1156.     break;
  1157.   case HA_ERR_LOCK_DEADLOCK:
  1158.     textno=ER_LOCK_DEADLOCK;
  1159.     break;
  1160.   case HA_ERR_READ_ONLY_TRANSACTION:
  1161.     textno=ER_READ_ONLY_TRANSACTION;
  1162.     break;
  1163.   case HA_ERR_CANNOT_ADD_FOREIGN:
  1164.     textno=ER_CANNOT_ADD_FOREIGN;
  1165.     break;
  1166.   case HA_ERR_ROW_IS_REFERENCED:
  1167.     textno=ER_ROW_IS_REFERENCED;
  1168.     break;
  1169.   case HA_ERR_NO_REFERENCED_ROW:
  1170.     textno=ER_NO_REFERENCED_ROW;
  1171.     break;
  1172.   case HA_ERR_NO_SUCH_TABLE:
  1173.   {
  1174.     /*
  1175.       We have to use path to find database name instead of using
  1176.       table->table_cache_key because if the table didn't exist, then
  1177.       table_cache_key was not set up
  1178.     */
  1179.     char *db;
  1180.     char buff[FN_REFLEN];
  1181.     uint length=dirname_part(buff,table->path);
  1182.     buff[length-1]=0;
  1183.     db=buff+dirname_length(buff);
  1184.     my_error(ER_NO_SUCH_TABLE,MYF(0),db,table->table_name);
  1185.     break;
  1186.   }
  1187.   default:
  1188.     {
  1189.       /* The error was "unknown" to this function.
  1190.  Ask handler if it has got a message for this error */
  1191.       bool temporary= FALSE;
  1192.       String str;
  1193.       temporary= get_error_message(error, &str);
  1194.       if (!str.is_empty())
  1195.       {
  1196. const char* engine= table_type();
  1197. if (temporary)
  1198.   my_error(ER_GET_TEMPORARY_ERRMSG,MYF(0),error,str.ptr(),engine);
  1199. else
  1200.   my_error(ER_GET_ERRMSG,MYF(0),error,str.ptr(),engine);
  1201.       }
  1202.       else       
  1203. my_error(ER_GET_ERRNO,errflag,error);
  1204.       DBUG_VOID_RETURN;
  1205.     }
  1206.   }
  1207.   my_error(textno,errflag,table->table_name,error);
  1208.   DBUG_VOID_RETURN;
  1209. }
  1212. /* 
  1213.    Return an error message specific to this handler
  1214.    
  1215.    SYNOPSIS
  1216.    error        error code previously returned by handler
  1217.    buf          Pointer to String where to add error message
  1218.    
  1219.    Returns true if this is a temporary error
  1220.  */
  1222. bool handler::get_error_message(int error, String* buf)
  1223. {
  1224.   return FALSE;
  1225. }
  1228. /* Return key if error because of duplicated keys */
  1230. uint handler::get_dup_key(int error)
  1231. {
  1232.   DBUG_ENTER("handler::get_dup_key");
  1233.   table->file->errkey  = (uint) -1;
  1234.   if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOUND_DUPP_UNIQUE ||
  1235.       error == HA_ERR_NULL_IN_SPATIAL)
  1236.     info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  1237.   DBUG_RETURN(table->file->errkey);
  1238. }
  1241. int handler::delete_table(const char *name)
  1242. {
  1243.   int error=0;
  1244.   for (const char **ext=bas_ext(); *ext ; ext++)
  1245.   {
  1246.     if (delete_file(name,*ext,2))
  1247.     {
  1248.       if ((error=errno) != ENOENT)
  1249. break;
  1250.     }
  1251.   }
  1252.   return error;
  1253. }
  1256. int handler::rename_table(const char * from, const char * to)
  1257. {
  1258.   int error= 0;
  1259.   for (const char **ext= bas_ext(); *ext ; ext++)
  1260.   {
  1261.     if (rename_file_ext(from, to, *ext))
  1262.     {
  1263.       if ((error=my_errno) != ENOENT)
  1264. break;
  1265.       error= 0;
  1266.     }
  1267.   }
  1268.   return error;
  1269. }
  1271. /*
  1272.   Tell the handler to turn on or off transaction in the handler
  1273. */
  1275. int ha_enable_transaction(THD *thd, bool on)
  1276. {
  1277.   int error=0;
  1279.   DBUG_ENTER("ha_enable_transaction");
  1280.   thd->transaction.on= on;
  1281.   DBUG_RETURN(error);
  1282. }
  1284. int handler::index_next_same(byte *buf, const byte *key, uint keylen)
  1285. {
  1286.   int error;
  1287.   if (!(error=index_next(buf)))
  1288.   {
  1289.     if (key_cmp_if_same(table, key, active_index, keylen))
  1290.     {
  1291.       table->status=STATUS_NOT_FOUND;
  1292.       error=HA_ERR_END_OF_FILE;
  1293.     }
  1294.   }
  1295.   return error;
  1296. }
  1299. /****************************************************************************
  1300. ** Some general functions that isn't in the handler class
  1301. ****************************************************************************/
  1303. /*
  1304.   Initiates table-file and calls apropriate database-creator
  1305.   Returns 1 if something got wrong
  1306. */
  1308. int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
  1309.     bool update_create_info)
  1310. {
  1311.   int error;
  1312.   TABLE table;
  1313.   char name_buff[FN_REFLEN];
  1314.   DBUG_ENTER("ha_create_table");
  1316.   if (openfrm(name,"",0,(uint) READ_ALL, 0, &table))
  1317.     DBUG_RETURN(1);
  1318.   if (update_create_info)
  1319.   {
  1320.     update_create_info_from_table(create_info, &table);
  1321.   }
  1322.   if (lower_case_table_names == 2 &&
  1323.       !(table.file->table_flags() & HA_FILE_BASED))
  1324.   {
  1325.     /* Ensure that handler gets name in lower case */
  1326.     strmov(name_buff, name);
  1327.     my_casedn_str(files_charset_info, name_buff);
  1328.     name= name_buff;
  1329.   }
  1331.   error=table.file->create(name,&table,create_info);
  1332.   VOID(closefrm(&table));
  1333.   if (error)
  1334.     my_error(ER_CANT_CREATE_TABLE,MYF(ME_BELL+ME_WAITTANG),name,error);
  1335.   DBUG_RETURN(error != 0);
  1336. }
  1338. /*
  1339.   Try to discover table from engine and
  1340.   if found, write the frm file to disk.
  1342.   RETURN VALUES:
  1343.   -1 : Table did not exists
  1344.    0 : Table created ok
  1345.    > 0 : Error, table existed but could not be created
  1347. */
  1349. int ha_create_table_from_engine(THD* thd,
  1350. const char *db,
  1351. const char *name)
  1352. {
  1353.   int error;
  1354.   const void *frmblob;
  1355.   uint frmlen;
  1356.   char path[FN_REFLEN];
  1357.   HA_CREATE_INFO create_info;
  1358.   TABLE table;
  1359.   DBUG_ENTER("ha_create_table_from_engine");
  1360.   DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
  1362.   bzero((char*) &create_info,sizeof(create_info));
  1363.   if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
  1364.   {
  1365.     /* Table could not be discovered and thus not created */
  1366.     DBUG_RETURN(error);
  1367.   }
  1369.   /*
  1370.     Table exists in handler and could be discovered
  1371.     frmblob and frmlen are set, write the frm to disk
  1372.   */
  1374.   (void)strxnmov(path,FN_REFLEN,mysql_data_home,"/",db,"/",name,NullS);
  1375.   // Save the frm file
  1376.   error= writefrm(path, frmblob, frmlen);
  1377.   my_free((char*) frmblob, MYF(0));
  1378.   if (error)
  1379.     DBUG_RETURN(2);
  1381.   if (openfrm(path,"",0,(uint) READ_ALL, 0, &table))
  1382.     DBUG_RETURN(3);
  1384.   update_create_info_from_table(&create_info, &table);
  1385.   create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
  1387.   if (lower_case_table_names == 2 &&
  1388.       !(table.file->table_flags() & HA_FILE_BASED))
  1389.   {
  1390.     /* Ensure that handler gets name in lower case */
  1391.     my_casedn_str(files_charset_info, path);
  1392.   }
  1393.   error=table.file->create(path,&table,&create_info);
  1394.   VOID(closefrm(&table));
  1396.   DBUG_RETURN(error != 0);
  1397. }
  1399. static int NEAR_F delete_file(const char *name,const char *ext,int extflag)
  1400. {
  1401.   char buff[FN_REFLEN];
  1402.   VOID(fn_format(buff,name,"",ext,extflag | 4));
  1403.   return(my_delete_with_symlink(buff,MYF(MY_WME)));
  1404. }
  1406. void st_ha_check_opt::init()
  1407. {
  1408.   flags= sql_flags= 0;
  1409.   sort_buffer_size = current_thd->variables.myisam_sort_buff_size;
  1410. }
  1413. /*****************************************************************************
  1414.   Key cache handling.
  1416.   This code is only relevant for ISAM/MyISAM tables
  1418.   key_cache->cache may be 0 only in the case where a key cache is not
  1419.   initialized or when we where not able to init the key cache in a previous
  1420.   call to ha_init_key_cache() (probably out of memory)
  1421. *****************************************************************************/
  1423. /* Init a key cache if it has not been initied before */
  1426. int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
  1427. {
  1428.   DBUG_ENTER("ha_init_key_cache");
  1430.   if (!key_cache->key_cache_inited)
  1431.   {
  1432.     pthread_mutex_lock(&LOCK_global_system_variables);
  1433.     long tmp_buff_size= (long) key_cache->param_buff_size;
  1434.     long tmp_block_size= (long) key_cache->param_block_size;
  1435.     uint division_limit= key_cache->param_division_limit;
  1436.     uint age_threshold=  key_cache->param_age_threshold;
  1437.     pthread_mutex_unlock(&LOCK_global_system_variables);
  1438.     DBUG_RETURN(!init_key_cache(key_cache,
  1439. tmp_block_size,
  1440. tmp_buff_size,
  1441. division_limit, age_threshold));
  1442.   }
  1443.   DBUG_RETURN(0);
  1444. }
  1447. /* Resize key cache */
  1449. int ha_resize_key_cache(KEY_CACHE *key_cache)
  1450. {
  1451.   DBUG_ENTER("ha_resize_key_cache");
  1453.   if (key_cache->key_cache_inited)
  1454.   {
  1455.     pthread_mutex_lock(&LOCK_global_system_variables);
  1456.     long tmp_buff_size= (long) key_cache->param_buff_size;
  1457.     long tmp_block_size= (long) key_cache->param_block_size;
  1458.     uint division_limit= key_cache->param_division_limit;
  1459.     uint age_threshold=  key_cache->param_age_threshold;
  1460.     pthread_mutex_unlock(&LOCK_global_system_variables);
  1461.     DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
  1462.   tmp_buff_size,
  1463.   division_limit, age_threshold));
  1464.   }
  1465.   DBUG_RETURN(0);
  1466. }
  1469. /* Change parameters for key cache (like size) */
  1471. int ha_change_key_cache_param(KEY_CACHE *key_cache)
  1472. {
  1473.   if (key_cache->key_cache_inited)
  1474.   {
  1475.     pthread_mutex_lock(&LOCK_global_system_variables);
  1476.     uint division_limit= key_cache->param_division_limit;
  1477.     uint age_threshold=  key_cache->param_age_threshold;
  1478.     pthread_mutex_unlock(&LOCK_global_system_variables);
  1479.     change_key_cache_param(key_cache, division_limit, age_threshold);
  1480.   }
  1481.   return 0;
  1482. }
  1484. /* Free memory allocated by a key cache */
  1486. int ha_end_key_cache(KEY_CACHE *key_cache)
  1487. {
  1488.   end_key_cache(key_cache, 1); // Can never fail
  1489.   return 0;
  1490. }
  1492. /* Move all tables from one key cache to another one */
  1494. int ha_change_key_cache(KEY_CACHE *old_key_cache,
  1495. KEY_CACHE *new_key_cache)
  1496. {
  1497.   mi_change_key_cache(old_key_cache, new_key_cache);
  1498.   return 0;
  1499. }
  1502. /*
  1503.   Try to discover one table from handler(s)
  1505.   RETURN
  1506.    -1  : Table did not exists
  1507.     0  : OK. In this case *frmblob and *frmlen are set
  1508.     >0 : error.  frmblob and frmlen may not be set
  1509. */
  1511. int ha_discover(THD *thd, const char *db, const char *name,
  1512. const void **frmblob, uint *frmlen)
  1513. {
  1514.   int error= -1; // Table does not exist in any handler
  1515.   DBUG_ENTER("ha_discover");
  1516.   DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
  1517.   if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
  1518.     DBUG_RETURN(error);
  1519. #ifdef HAVE_NDBCLUSTER_DB
  1520.   if (have_ndbcluster == SHOW_OPTION_YES)
  1521.     error= ndbcluster_discover(thd, db, name, frmblob, frmlen);
  1522. #endif
  1523.   if (!error)
  1524.     statistic_increment(ha_discover_count,&LOCK_status);
  1525.   DBUG_RETURN(error);
  1526. }
  1529. /*
  1530.   Call this function in order to give the handler the possiblity 
  1531.   to ask engine if there are any new tables that should be written to disk 
  1532.   or any dropped tables that need to be removed from disk
  1533. */
  1535. int
  1536. ha_find_files(THD *thd,const char *db,const char *path,
  1537.       const char *wild, bool dir, List<char> *files)
  1538. {
  1539.   int error= 0;
  1540.   DBUG_ENTER("ha_find_files");
  1541.   DBUG_PRINT("enter", ("db: %s, path: %s, wild: %s, dir: %d", 
  1542.        db, path, wild, dir));
  1543. #ifdef HAVE_NDBCLUSTER_DB
  1544.   if (have_ndbcluster == SHOW_OPTION_YES)
  1545.     error= ndbcluster_find_files(thd, db, path, wild, dir, files);
  1546. #endif
  1547.   DBUG_RETURN(error);
  1548. }
  1551. /*
  1552.   Ask handler if the table exists in engine
  1554.   RETURN
  1555.     0                   Table does not exist
  1556.     1                   Table exists
  1557.     #                   Error code
  1559.  */
  1560. int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
  1561. {
  1562.   int error= 0;
  1563.   DBUG_ENTER("ha_table_exists_in_engine");
  1564.   DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
  1565. #ifdef HAVE_NDBCLUSTER_DB
  1566.   if (have_ndbcluster == SHOW_OPTION_YES)
  1567.     error= ndbcluster_table_exists_in_engine(thd, db, name);
  1568. #endif
  1569.   DBUG_PRINT("exit", ("error: %d", error));
  1570.   DBUG_RETURN(error);
  1571. }
  1574. /*
  1575.   Read first row between two ranges.
  1576.   Store ranges for future calls to read_range_next
  1578.   SYNOPSIS
  1579.     read_range_first()
  1580.     start_key Start key. Is 0 if no min range
  1581.     end_key End key.  Is 0 if no max range
  1582.     eq_range_arg Set to 1 if start_key == end_key
  1583.     sorted Set to 1 if result should be sorted per key
  1585.   NOTES
  1586.     Record is read into table->record[0]
  1588.   RETURN
  1589.     0 Found row
  1590.     HA_ERR_END_OF_FILE No rows in range
  1591.     # Error code
  1592. */
  1594. int handler::read_range_first(const key_range *start_key,
  1595.       const key_range *end_key,
  1596.       bool eq_range_arg, bool sorted)
  1597. {
  1598.   int result;
  1599.   DBUG_ENTER("handler::read_range_first");
  1601.   eq_range= eq_range_arg;
  1602.   end_range= 0;
  1603.   if (end_key)
  1604.   {
  1605.     end_range= &save_end_range;
  1606.     save_end_range= *end_key;
  1607.     key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
  1608.   (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
  1609.   }
  1610.   range_key_part= table->key_info[active_index].key_part;
  1612.   if (!start_key) // Read first record
  1613.     result= index_first(table->record[0]);
  1614.   else
  1615.     result= index_read(table->record[0],
  1616.        start_key->key,
  1617.        start_key->length,
  1618.        start_key->flag);
  1619.   if (result)
  1620.     DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
  1621. ? HA_ERR_END_OF_FILE
  1622. : result);
  1624.   DBUG_RETURN (compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
  1625. }
  1628. /*
  1629.   Read next row between two ranges.
  1631.   SYNOPSIS
  1632.     read_range_next()
  1634.   NOTES
  1635.     Record is read into table->record[0]
  1637.   RETURN
  1638.     0 Found row
  1639.     HA_ERR_END_OF_FILE No rows in range
  1640.     # Error code
  1641. */
  1643. int handler::read_range_next()
  1644. {
  1645.   int result;
  1646.   DBUG_ENTER("handler::read_range_next");
  1648.   if (eq_range)
  1649.   {
  1650.     /* We trust that index_next_same always gives a row in range */
  1651.     DBUG_RETURN(index_next_same(table->record[0],
  1652.                                 end_range->key,
  1653.                                 end_range->length));
  1654.   }
  1655.   result= index_next(table->record[0]);
  1656.   if (result)
  1657.     DBUG_RETURN(result);
  1658.   DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
  1659. }
  1662. /*
  1663.   Compare if found key (in row) is over max-value
  1665.   SYNOPSIS
  1666.     compare_key
  1667.     range range to compare to row. May be 0 for no range
  1668.  
  1669.   NOTES
  1670.     See key.cc::key_cmp() for details
  1672.   RETURN
  1673.     The return value is SIGN(key_in_row - range_key):
  1675.     0 Key is equal to range or 'range' == 0 (no range)
  1676.    -1 Key is less than range
  1677.     1 Key is larger than range
  1678. */
  1680. int handler::compare_key(key_range *range)
  1681. {
  1682.   int cmp;
  1683.   if (!range)
  1684.     return 0; // No max range
  1685.   cmp= key_cmp(range_key_part, range->key, range->length);
  1686.   if (!cmp)
  1687.     cmp= key_compare_result_on_equal;
  1688.   return cmp;
  1689. }
  1691. int handler::index_read_idx(byte * buf, uint index, const byte * key,
  1692.      uint key_len, enum ha_rkey_function find_flag)
  1693. {
  1694.   int error= ha_index_init(index);
  1695.   if (!error)
  1696.     error= index_read(buf, key, key_len, find_flag);
  1697.   if (!error)
  1698.     error= ha_index_end();
  1699.   return error;
  1700. }
  1703. /*
  1704.   Returns a list of all known extensions.
  1706.   SYNOPSIS
  1707.     ha_known_exts()
  1708.  
  1709.   NOTES
  1710.     No mutexes, worst case race is a minor surplus memory allocation
  1711.     We have to recreate the extension map if mysqld is restarted (for example
  1712.     within libmysqld)
  1714.   RETURN VALUE
  1715.     pointer pointer to TYPELIB structure
  1716. */
  1718. TYPELIB *ha_known_exts(void)
  1719. {
  1720.   if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
  1721.   {
  1722.     show_table_type_st *types;
  1723.     List<char> found_exts;
  1724.     List_iterator_fast<char> it(found_exts);
  1725.     const char **ext, *old_ext;
  1727.     known_extensions_id= mysys_usage_id;
  1728.     found_exts.push_back((char*) ".db");
  1729.     for (types= sys_table_types; types->type; types++)
  1730.     {      
  1731.       if (*types->value == SHOW_OPTION_YES)
  1732.       {
  1733. handler *file= get_new_handler(0,(enum db_type) types->db_type);
  1734. for (ext= file->bas_ext(); *ext; ext++)
  1735. {
  1736.   while ((old_ext= it++))
  1737.           {
  1738.     if (!strcmp(old_ext, *ext))
  1739.       break;
  1740.           }
  1741.   if (!old_ext)
  1742.     found_exts.push_back((char *) *ext);
  1744.   it.rewind();
  1745. }
  1746. delete file;
  1747.       }
  1748.     }
  1749.     ext= (const char **) my_once_alloc(sizeof(char *)*
  1750.                                        (found_exts.elements+1),
  1751.                                        MYF(MY_WME | MY_FAE));
  1752.     
  1753.     DBUG_ASSERT(ext);
  1754.     known_extensions.count= found_exts.elements;
  1755.     known_extensions.type_names= ext;
  1757.     while ((old_ext= it++))
  1758.       *ext++= old_ext;
  1759.     *ext= 0;
  1760.   }
  1761.   return &known_extensions;
  1762. }