← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.h

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.h
20
20
#pragma interface                       /* gcc class implementation */
21
21
#endif
22
22
 
23
 
#include <my_handler.h>
24
 
#include <keycache.h>
 
23
#include <mysys/my_handler.h>
 
24
#include <storage/myisam/keycache.h>
25
25
 
26
26
#ifndef NO_HASH
27
27
#define NO_HASH                         /* Not yet implemented */
45
45
#define HA_ADMIN_NEEDS_CHECK    -12
46
46
 
47
47
/* Bits to show what an alter table will do */
48
 
#include <sql_bitmap.h>
 
48
#include <drizzled/sql_bitmap.h>
49
49
 
50
50
#define HA_MAX_ALTER_FLAGS 39
51
51
typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
552
552
   void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);
553
553
   handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);
554
554
   void (*drop_database)(handlerton *hton, char* path);
555
 
   int (*panic)(handlerton *hton, enum ha_panic_function flag);
556
555
   int (*start_consistent_snapshot)(handlerton *hton, THD *thd);
557
556
   bool (*flush_logs)(handlerton *hton);
558
557
   bool (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat);
559
558
   int (*fill_files_table)(handlerton *hton, THD *thd,
560
559
                           TABLE_LIST *tables,
561
560
                           class Item *cond);
562
 
   uint32 flags;                                /* global handler flags */
 
561
   uint32_t flags;                                /* global handler flags */
563
562
   int (*release_temporary_latches)(handlerton *hton, THD *thd);
564
563
 
565
564
   int (*discover)(handlerton *hton, THD* thd, const char *db, 
568
567
                   size_t *frmlen);
569
568
   int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,
570
569
                                 const char *name);
571
 
   uint32 license; /* Flag for Engine License */
 
570
   uint32_t license; /* Flag for Engine License */
572
571
   void *data; /* Location for engines to keep personal structures */
573
572
};
574
573
 
726
725
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
727
726
                         ISO_REPEATABLE_READ, ISO_SERIALIZABLE};
728
727
 
729
 
 
730
 
enum ndb_distribution { ND_KEYHASH= 0, ND_LINHASH= 1 };
731
 
 
732
 
 
733
728
typedef struct {
734
729
  uint64_t data_file_length;
735
730
  uint64_t max_data_file_length;
747
742
class Item;
748
743
struct st_table_log_memory_entry;
749
744
 
750
 
#define NOT_A_PARTITION_ID ((uint32)-1)
 
745
#define NOT_A_PARTITION_ID ((uint32_t)-1)
751
746
 
752
747
enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };
753
748
 
831
826
  }
832
827
private:
833
828
  /* Function primitive that is called prior to locking tables */
834
 
  virtual void do_prelock(TABLE **tables __attribute__((__unused__)),
835
 
                          uint count __attribute__((__unused__)))
 
829
  virtual void do_prelock(TABLE **tables __attribute__((unused)),
 
830
                          uint count __attribute__((unused)))
836
831
  {
837
832
    /* Default is to do nothing */
838
833
  }
845
840
 
846
841
     @return Error code or zero.
847
842
   */
848
 
  virtual int do_postlock(TABLE **tables __attribute__((__unused__)),
849
 
                          uint count __attribute__((__unused__)))
 
843
  virtual int do_postlock(TABLE **tables __attribute__((unused)),
 
844
                          uint count __attribute__((unused)))
850
845
  {
851
846
    return 0;                           /* Default is to do nothing */
852
847
  }
922
917
  uint (*next) (range_seq_t seq, KEY_MULTI_RANGE *range);
923
918
} RANGE_SEQ_IF;
924
919
 
925
 
uint16 &mrr_persistent_flag_storage(range_seq_t seq, uint idx);
 
920
uint16_t &mrr_persistent_flag_storage(range_seq_t seq, uint idx);
926
921
char* &mrr_get_ptr_by_idx(range_seq_t seq, uint idx);
927
922
 
928
923
class COST_VECT
1316
1311
  /* Estimates calculation */
1317
1312
  virtual double scan_time(void)
1318
1313
  { return uint64_t2double(stats.data_file_length) / IO_SIZE + 2; }
1319
 
  virtual double read_time(uint index __attribute__((__unused__)),
 
1314
  virtual double read_time(uint index __attribute__((unused)),
1320
1315
                           uint ranges, ha_rows rows)
1321
1316
  { return rows2double(ranges+rows); }
1322
1317
 
1379
1374
  */
1380
1375
  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }
1381
1376
 
1382
 
  virtual const char *index_type(uint key_number __attribute__((__unused__)))
 
1377
  virtual const char *index_type(uint key_number __attribute__((unused)))
1383
1378
  { assert(0); return "";}
1384
1379
 
1385
1380
 
1415
1410
    @retval  0           Success
1416
1411
    @retval  >0          Error code
1417
1412
  */
1418
 
  virtual int exec_bulk_update(uint *dup_key_found __attribute__((__unused__)))
 
1413
  virtual int exec_bulk_update(uint *dup_key_found __attribute__((unused)))
1419
1414
  {
1420
1415
    assert(false);
1421
1416
    return HA_ERR_WRONG_COMMAND;
1458
1453
  virtual int index_read_idx_map(uchar * buf, uint index, const uchar * key,
1459
1454
                                 key_part_map keypart_map,
1460
1455
                                 enum ha_rkey_function find_flag);
1461
 
  virtual int index_next(uchar * buf __attribute__((__unused__)))
1462
 
   { return  HA_ERR_WRONG_COMMAND; }
1463
 
  virtual int index_prev(uchar * buf __attribute__((__unused__)))
1464
 
   { return  HA_ERR_WRONG_COMMAND; }
1465
 
  virtual int index_first(uchar * buf __attribute__((__unused__)))
1466
 
   { return  HA_ERR_WRONG_COMMAND; }
1467
 
  virtual int index_last(uchar * buf __attribute__((__unused__)))
1468
 
   { return  HA_ERR_WRONG_COMMAND; }
1469
 
  virtual int index_next_same(uchar *buf __attribute__((__unused__)),
1470
 
                              const uchar *key __attribute__((__unused__)),
1471
 
                              uint keylen __attribute__((__unused__)));
 
1456
  virtual int index_next(uchar * buf __attribute__((unused)))
 
1457
   { return  HA_ERR_WRONG_COMMAND; }
 
1458
  virtual int index_prev(uchar * buf __attribute__((unused)))
 
1459
   { return  HA_ERR_WRONG_COMMAND; }
 
1460
  virtual int index_first(uchar * buf __attribute__((unused)))
 
1461
   { return  HA_ERR_WRONG_COMMAND; }
 
1462
  virtual int index_last(uchar * buf __attribute__((unused)))
 
1463
   { return  HA_ERR_WRONG_COMMAND; }
 
1464
  virtual int index_next_same(uchar *buf __attribute__((unused)),
 
1465
                              const uchar *key __attribute__((unused)),
 
1466
                              uint keylen __attribute__((unused)));
1472
1467
  /**
1473
1468
     @brief
1474
1469
     The following functions works like index_read, but it find the last
1486
1481
  virtual int read_range_next();
1487
1482
  int compare_key(key_range *range);
1488
1483
  int compare_key2(key_range *range);
1489
 
  virtual int rnd_next(uchar *buf __attribute__((__unused__)))=0;
1490
 
  virtual int rnd_pos(uchar * buf __attribute__((__unused__)),
1491
 
                      uchar *pos __attribute__((__unused__)))=0;
 
1484
  virtual int rnd_next(uchar *buf __attribute__((unused)))=0;
 
1485
  virtual int rnd_pos(uchar * buf __attribute__((unused)),
 
1486
                      uchar *pos __attribute__((unused)))=0;
1492
1487
  /**
1493
1488
    One has to use this method when to find
1494
1489
    random position by record as the plain
1501
1496
    The following function is only needed for tables that may be temporary
1502
1497
    tables during joins.
1503
1498
  */
1504
 
  virtual int restart_rnd_next(uchar *buf __attribute__((__unused__)),
1505
 
                               uchar *pos __attribute__((__unused__)))
1506
 
    { return HA_ERR_WRONG_COMMAND; }
1507
 
  virtual int rnd_same(uchar *buf __attribute__((__unused__)),
1508
 
                       uint inx __attribute__((__unused__)))
1509
 
    { return HA_ERR_WRONG_COMMAND; }
1510
 
  virtual ha_rows records_in_range(uint inx __attribute__((__unused__)),
1511
 
                                   key_range *min_key __attribute__((__unused__)),
1512
 
                                   key_range *max_key __attribute__((__unused__)))
 
1499
  virtual int restart_rnd_next(uchar *buf __attribute__((unused)),
 
1500
                               uchar *pos __attribute__((unused)))
 
1501
    { return HA_ERR_WRONG_COMMAND; }
 
1502
  virtual int rnd_same(uchar *buf __attribute__((unused)),
 
1503
                       uint inx __attribute__((unused)))
 
1504
    { return HA_ERR_WRONG_COMMAND; }
 
1505
  virtual ha_rows records_in_range(uint inx __attribute__((unused)),
 
1506
                                   key_range *min_key __attribute__((unused)),
 
1507
                                   key_range *max_key __attribute__((unused)))
1513
1508
    { return (ha_rows) 10; }
1514
1509
  virtual void position(const uchar *record)=0;
1515
1510
  virtual int info(uint)=0; // see my_base.h for full description
1516
 
  virtual uint32 calculate_key_hash_value(Field **field_array __attribute__((__unused__)))
 
1511
  virtual uint32_t calculate_key_hash_value(Field **field_array __attribute__((unused)))
1517
1512
  { assert(0); return 0; }
1518
 
  virtual int extra(enum ha_extra_function operation __attribute__((__unused__)))
 
1513
  virtual int extra(enum ha_extra_function operation __attribute__((unused)))
1519
1514
  { return 0; }
1520
1515
  virtual int extra_opt(enum ha_extra_function operation,
1521
 
                        uint32_t cache_size __attribute__((__unused__)))
 
1516
                        uint32_t cache_size __attribute__((unused)))
1522
1517
  { return extra(operation); }
1523
1518
 
1524
1519
  /**
1542
1537
  */
1543
1538
  virtual void try_semi_consistent_read(bool) {}
1544
1539
  virtual void unlock_row(void) {}
1545
 
  virtual int start_stmt(THD *thd __attribute__((__unused__)),
1546
 
                         thr_lock_type lock_type __attribute__((__unused__)))
 
1540
  virtual int start_stmt(THD *thd __attribute__((unused)),
 
1541
                         thr_lock_type lock_type __attribute__((unused)))
1547
1542
  {return 0;}
1548
1543
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
1549
1544
                                  uint64_t nb_desired_values,
1569
1564
      insert_id_for_cur_row;
1570
1565
  }
1571
1566
 
1572
 
  virtual void update_create_info(HA_CREATE_INFO *create_info __attribute__((__unused__))) {}
 
1567
  virtual void update_create_info(HA_CREATE_INFO *create_info __attribute__((unused))) {}
1573
1568
  int check_old_types(void);
1574
 
  virtual int assign_to_keycache(THD* thd __attribute__((__unused__)),
1575
 
                                 HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
1569
  virtual int assign_to_keycache(THD* thd __attribute__((unused)),
 
1570
                                 HA_CHECK_OPT* check_opt __attribute__((unused)))
1576
1571
  { return HA_ADMIN_NOT_IMPLEMENTED; }
1577
1572
  /* end of the list of admin commands */
1578
1573
 
1579
1574
  virtual int indexes_are_disabled(void) {return 0;}
1580
1575
  virtual char *update_table_comment(const char * comment)
1581
1576
  { return (char*) comment;}
1582
 
  virtual void append_create_info(String *packet __attribute__((__unused__)))
 
1577
  virtual void append_create_info(String *packet __attribute__((unused)))
1583
1578
  {}
1584
1579
  /**
1585
1580
      If index == MAX_KEY then a check for table is made and if index <
1591
1586
    @retval   true            Foreign key defined on table or index
1592
1587
    @retval   false           No foreign key defined
1593
1588
  */
1594
 
  virtual bool is_fk_defined_on_table_or_index(uint index __attribute__((__unused__)))
 
1589
  virtual bool is_fk_defined_on_table_or_index(uint index __attribute__((unused)))
1595
1590
  { return false; }
1596
1591
  virtual char* get_foreign_key_create_info(void)
1597
1592
  { return(NULL);}  /* gets foreign key create string from InnoDB */
1598
1593
  /** used in ALTER TABLE; 1 if changing storage engine is allowed */
1599
1594
  virtual bool can_switch_engines(void) { return 1; }
1600
1595
  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
1601
 
  virtual int get_foreign_key_list(THD *thd __attribute__((__unused__)),
1602
 
                                   List<FOREIGN_KEY_INFO> *f_key_list __attribute__((__unused__)))
 
1596
  virtual int get_foreign_key_list(THD *thd __attribute__((unused)),
 
1597
                                   List<FOREIGN_KEY_INFO> *f_key_list __attribute__((unused)))
1603
1598
  { return 0; }
1604
1599
  virtual uint referenced_by_foreign_key() { return 0;}
1605
1600
  virtual void init_table_handle_for_HANDLER()
1606
1601
  { return; }       /* prepare InnoDB for HANDLER */
1607
 
  virtual void free_foreign_key_create_info(char* str __attribute__((__unused__))) {}
 
1602
  virtual void free_foreign_key_create_info(char* str __attribute__((unused))) {}
1608
1603
  /** The following can be called without an open handler */
1609
1604
  virtual const char *table_type() const =0;
1610
1605
  /**
1620
1615
  */
1621
1616
  virtual const char **bas_ext() const =0;
1622
1617
 
1623
 
  virtual int get_default_no_partitions(HA_CREATE_INFO *info __attribute__((__unused__))) { return 1;}
1624
 
  virtual bool get_no_parts(const char *name __attribute__((__unused__)),
 
1618
  virtual int get_default_no_partitions(HA_CREATE_INFO *info __attribute__((unused))) { return 1;}
 
1619
  virtual bool get_no_parts(const char *name __attribute__((unused)),
1625
1620
                            uint *no_parts)
1626
1621
  {
1627
1622
    *no_parts= 0;
1630
1625
 
1631
1626
  virtual uint32_t index_flags(uint idx, uint part, bool all_parts) const =0;
1632
1627
 
1633
 
  virtual int add_index(TABLE *table_arg __attribute__((__unused__)),
1634
 
                        KEY *key_info __attribute__((__unused__)),
1635
 
                        uint num_of_keys __attribute__((__unused__)))
1636
 
  { return (HA_ERR_WRONG_COMMAND); }
1637
 
  virtual int prepare_drop_index(TABLE *table_arg __attribute__((__unused__)),
1638
 
                                 uint *key_num __attribute__((__unused__)),
1639
 
                                 uint num_of_keys __attribute__((__unused__)))
1640
 
  { return (HA_ERR_WRONG_COMMAND); }
1641
 
  virtual int final_drop_index(TABLE *table_arg __attribute__((__unused__)))
 
1628
  virtual int add_index(TABLE *table_arg __attribute__((unused)),
 
1629
                        KEY *key_info __attribute__((unused)),
 
1630
                        uint num_of_keys __attribute__((unused)))
 
1631
  { return (HA_ERR_WRONG_COMMAND); }
 
1632
  virtual int prepare_drop_index(TABLE *table_arg __attribute__((unused)),
 
1633
                                 uint *key_num __attribute__((unused)),
 
1634
                                 uint num_of_keys __attribute__((unused)))
 
1635
  { return (HA_ERR_WRONG_COMMAND); }
 
1636
  virtual int final_drop_index(TABLE *table_arg __attribute__((unused)))
1642
1637
  { return (HA_ERR_WRONG_COMMAND); }
1643
1638
 
1644
1639
  uint max_record_length() const
1658
1653
  virtual uint max_supported_key_parts(void) const { return MAX_REF_PARTS; }
1659
1654
  virtual uint max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
1660
1655
  virtual uint max_supported_key_part_length(void) const { return 255; }
1661
 
  virtual uint min_record_length(uint options __attribute__((__unused__))) const
 
1656
  virtual uint min_record_length(uint options __attribute__((unused))) const
1662
1657
  { return 1; }
1663
1658
 
1664
1659
  virtual bool low_byte_first(void) const { return 1; }
1694
1689
                                     enum thr_lock_type lock_type)=0;
1695
1690
 
1696
1691
  /** Type of table for caching query */
1697
 
  virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
 
1692
  virtual uint8_t table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
1698
1693
 
1699
1694
 
1700
1695
  /**
1728
1723
  */
1729
1724
 
1730
1725
  virtual bool
1731
 
    register_query_cache_table(THD *thd __attribute__((__unused__)),
1732
 
                               char *table_key __attribute__((__unused__)),
1733
 
                               uint key_length __attribute__((__unused__)),
 
1726
    register_query_cache_table(THD *thd __attribute__((unused)),
 
1727
                               char *table_key __attribute__((unused)),
 
1728
                               uint key_length __attribute__((unused)),
1734
1729
                               qc_engine_callback *engine_callback,
1735
 
                               uint64_t *engine_data __attribute__((__unused__)))
 
1730
                               uint64_t *engine_data __attribute__((unused)))
1736
1731
  {
1737
1732
    *engine_callback= 0;
1738
1733
    return true;
1786
1781
 virtual void cond_pop(void) { return; }
1787
1782
 
1788
1783
 virtual Item
1789
 
   *idx_cond_push(uint keyno __attribute__((__unused__)),
1790
 
                  Item* idx_cond __attribute__((__unused__)))
 
1784
   *idx_cond_push(uint keyno __attribute__((unused)),
 
1785
                  Item* idx_cond __attribute__((unused)))
1791
1786
 { return idx_cond; }
1792
1787
 
1793
1788
 /*
1794
1789
    Part of old fast alter table, to be depricated
1795
1790
  */
1796
1791
 virtual bool
1797
 
   check_if_incompatible_data(HA_CREATE_INFO *create_info __attribute__((__unused__)),
1798
 
                              uint table_changes __attribute__((__unused__)))
 
1792
   check_if_incompatible_data(HA_CREATE_INFO *create_info __attribute__((unused)),
 
1793
                              uint table_changes __attribute__((unused)))
1799
1794
 { return COMPATIBLE_DATA_NO; }
1800
1795
 
1801
1796
 /* On-line ALTER TABLE interface */
1824
1819
      implementation.
1825
1820
 */
1826
1821
 virtual int
1827
 
   check_if_supported_alter(TABLE *altered_table __attribute__((__unused__)),
 
1822
   check_if_supported_alter(TABLE *altered_table __attribute__((unused)),
1828
1823
                            HA_CREATE_INFO *create_info,
1829
 
                            HA_ALTER_FLAGS *alter_flags __attribute__((__unused__)),
 
1824
                            HA_ALTER_FLAGS *alter_flags __attribute__((unused)),
1830
1825
                            uint table_changes)
1831
1826
 {
1832
1827
   if (this->check_if_incompatible_data(create_info, table_changes)
1848
1843
   @retval   0      OK
1849
1844
   @retval   error  error code passed from storage engine
1850
1845
 */
1851
 
 virtual int alter_table_phase1(THD *thd __attribute__((__unused__)),
1852
 
                                TABLE *altered_table __attribute__((__unused__)),
1853
 
                                HA_CREATE_INFO *create_info __attribute__((__unused__)),
1854
 
                                HA_ALTER_INFO *alter_info __attribute__((__unused__)),
1855
 
                                HA_ALTER_FLAGS *alter_flags  __attribute__((__unused__)))
 
1846
 virtual int alter_table_phase1(THD *thd __attribute__((unused)),
 
1847
                                TABLE *altered_table __attribute__((unused)),
 
1848
                                HA_CREATE_INFO *create_info __attribute__((unused)),
 
1849
                                HA_ALTER_INFO *alter_info __attribute__((unused)),
 
1850
                                HA_ALTER_FLAGS *alter_flags  __attribute__((unused)))
1856
1851
 {
1857
1852
   return HA_ERR_UNSUPPORTED;
1858
1853
 }
1874
1869
      this call is to be wrapped with a DDL lock. This is currently NOT
1875
1870
      supported.
1876
1871
 */
1877
 
 virtual int alter_table_phase2(THD *thd  __attribute__((__unused__)),
1878
 
                                TABLE *altered_table  __attribute__((__unused__)),
1879
 
                                HA_CREATE_INFO *create_info __attribute__((__unused__)),
1880
 
                                HA_ALTER_INFO *alter_info __attribute__((__unused__)),
1881
 
                                HA_ALTER_FLAGS *alter_flags __attribute__((__unused__)))
 
1872
 virtual int alter_table_phase2(THD *thd  __attribute__((unused)),
 
1873
                                TABLE *altered_table  __attribute__((unused)),
 
1874
                                HA_CREATE_INFO *create_info __attribute__((unused)),
 
1875
                                HA_ALTER_INFO *alter_info __attribute__((unused)),
 
1876
                                HA_ALTER_FLAGS *alter_flags __attribute__((unused)))
1882
1877
 {
1883
1878
   return HA_ERR_UNSUPPORTED;
1884
1879
 }
1889
1884
    @param    thd               The thread handle
1890
1885
    @param    table             The altered table, re-opened
1891
1886
 */
1892
 
 virtual int alter_table_phase3(THD *thd __attribute__((__unused__)),
1893
 
                                TABLE *table __attribute__((__unused__)))
 
1887
 virtual int alter_table_phase3(THD *thd __attribute__((unused)),
 
1888
                                TABLE *table __attribute__((unused)))
1894
1889
 {
1895
1890
   return HA_ERR_UNSUPPORTED;
1896
1891
 }
1965
1960
 
1966
1961
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
1967
1962
  virtual int index_init(uint idx,
1968
 
                         bool sorted __attribute__((__unused__)))
 
1963
                         bool sorted __attribute__((unused)))
1969
1964
  { active_index= idx; return 0; }
1970
1965
  virtual int index_end() { active_index= MAX_KEY; return 0; }
1971
1966
  /**
2029
2024
  }
2030
2025
  virtual void release_auto_increment(void) { return; };
2031
2026
  /** admin commands - called from mysql_admin_table */
2032
 
  virtual int check_for_upgrade(HA_CHECK_OPT *check_opt __attribute__((__unused__)))
 
2027
  virtual int check_for_upgrade(HA_CHECK_OPT *check_opt __attribute__((unused)))
2033
2028
  { return 0; }
2034
 
  virtual int check(THD* thd __attribute__((__unused__)),
2035
 
                    HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
2029
  virtual int check(THD* thd __attribute__((unused)),
 
2030
                    HA_CHECK_OPT* check_opt __attribute__((unused)))
2036
2031
  { return HA_ADMIN_NOT_IMPLEMENTED; }
2037
2032
 
2038
2033
  /**
2040
2035
     to specify CHECK option to use to call check()
2041
2036
     upon the table.
2042
2037
  */
2043
 
  virtual int repair(THD* thd __attribute__((__unused__)),
2044
 
                     HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
2038
  virtual int repair(THD* thd __attribute__((unused)),
 
2039
                     HA_CHECK_OPT* check_opt __attribute__((unused)))
2045
2040
  { return HA_ADMIN_NOT_IMPLEMENTED; }
2046
 
  virtual void start_bulk_insert(ha_rows rows __attribute__((__unused__)))
 
2041
  virtual void start_bulk_insert(ha_rows rows __attribute__((unused)))
2047
2042
  {}
2048
2043
  virtual int end_bulk_insert(void) { return 0; }
2049
 
  virtual int index_read(uchar * buf __attribute__((__unused__)),
2050
 
                         const uchar * key __attribute__((__unused__)),
2051
 
                         uint key_len __attribute__((__unused__)),
2052
 
                         enum ha_rkey_function find_flag __attribute__((__unused__)))
 
2044
  virtual int index_read(uchar * buf __attribute__((unused)),
 
2045
                         const uchar * key __attribute__((unused)),
 
2046
                         uint key_len __attribute__((unused)),
 
2047
                         enum ha_rkey_function find_flag __attribute__((unused)))
2053
2048
   { return  HA_ERR_WRONG_COMMAND; }
2054
 
  virtual int index_read_last(uchar * buf __attribute__((__unused__)),
2055
 
                              const uchar * key __attribute__((__unused__)),
2056
 
                              uint key_len __attribute__((__unused__)))
 
2049
  virtual int index_read_last(uchar * buf __attribute__((unused)),
 
2050
                              const uchar * key __attribute__((unused)),
 
2051
                              uint key_len __attribute__((unused)))
2057
2052
   { return (my_errno= HA_ERR_WRONG_COMMAND); }
2058
2053
  /**
2059
2054
    This method is similar to update_row, however the handler doesn't need
2068
2063
    @retval  0   Bulk delete used by handler
2069
2064
    @retval  1   Bulk delete not used, normal operation used
2070
2065
  */
2071
 
  virtual int bulk_update_row(const uchar *old_data __attribute__((__unused__)),
2072
 
                              uchar *new_data __attribute__((__unused__)),
2073
 
                              uint *dup_key_found __attribute__((__unused__)))
 
2066
  virtual int bulk_update_row(const uchar *old_data __attribute__((unused)),
 
2067
                              uchar *new_data __attribute__((unused)),
 
2068
                              uint *dup_key_found __attribute__((unused)))
2074
2069
  {
2075
2070
    assert(false);
2076
2071
    return HA_ERR_WRONG_COMMAND;
2089
2084
    is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
2090
2085
    returned by storage engines that don't support this operation.
2091
2086
  */
2092
 
  virtual int reset_auto_increment(uint64_t value __attribute__((__unused__)))
 
2087
  virtual int reset_auto_increment(uint64_t value __attribute__((unused)))
2093
2088
  { return HA_ERR_WRONG_COMMAND; }
2094
 
  virtual int optimize(THD* thd __attribute__((__unused__)),
2095
 
                       HA_CHECK_OPT* check_opt __attribute__((__unused__)))
2096
 
  { return HA_ADMIN_NOT_IMPLEMENTED; }
2097
 
  virtual int analyze(THD* thd __attribute__((__unused__)),
2098
 
                      HA_CHECK_OPT* check_opt __attribute__((__unused__)))
2099
 
  { return HA_ADMIN_NOT_IMPLEMENTED; }
2100
 
  virtual bool check_and_repair(THD *thd __attribute__((__unused__)))
 
2089
  virtual int optimize(THD* thd __attribute__((unused)),
 
2090
                       HA_CHECK_OPT* check_opt __attribute__((unused)))
 
2091
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
2092
  virtual int analyze(THD* thd __attribute__((unused)),
 
2093
                      HA_CHECK_OPT* check_opt __attribute__((unused)))
 
2094
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
2095
  virtual bool check_and_repair(THD *thd __attribute__((unused)))
2101
2096
  { return true; }
2102
 
  virtual int disable_indexes(uint mode __attribute__((__unused__)))
2103
 
  { return HA_ERR_WRONG_COMMAND; }
2104
 
  virtual int enable_indexes(uint mode __attribute__((__unused__)))
2105
 
  { return HA_ERR_WRONG_COMMAND; }
2106
 
  virtual int discard_or_import_tablespace(bool discard __attribute__((__unused__)))
 
2097
  virtual int disable_indexes(uint mode __attribute__((unused)))
 
2098
  { return HA_ERR_WRONG_COMMAND; }
 
2099
  virtual int enable_indexes(uint mode __attribute__((unused)))
 
2100
  { return HA_ERR_WRONG_COMMAND; }
 
2101
  virtual int discard_or_import_tablespace(bool discard __attribute__((unused)))
2107
2102
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
2108
2103
  virtual void prepare_for_alter(void) { return; }
2109
2104
  virtual void drop_table(const char *name);
2110
 
  virtual int create(const char *name __attribute__((__unused__)),
2111
 
                     TABLE *form __attribute__((__unused__)),
2112
 
                     HA_CREATE_INFO *info __attribute__((__unused__)))=0;
 
2105
  virtual int create(const char *name __attribute__((unused)),
 
2106
                     TABLE *form __attribute__((unused)),
 
2107
                     HA_CREATE_INFO *info __attribute__((unused)))=0;
2113
2108
 
2114
 
  virtual int create_handler_files(const char *name __attribute__((__unused__)),
2115
 
                                   const char *old_name __attribute__((__unused__)),
2116
 
                                   int action_flag __attribute__((__unused__)),
2117
 
                                   HA_CREATE_INFO *info __attribute__((__unused__)))
 
2109
  virtual int create_handler_files(const char *name __attribute__((unused)),
 
2110
                                   const char *old_name __attribute__((unused)),
 
2111
                                   int action_flag __attribute__((unused)),
 
2112
                                   HA_CREATE_INFO *info __attribute__((unused)))
2118
2113
  { return false; }
2119
2114
};
2120
2115
 
2218
2213
  return db_type == NULL ? "UNKNOWN" : hton2plugin[db_type->slot]->name.str;
2219
2214
}
2220
2215
 
2221
 
static inline bool ha_check_storage_engine_flag(const handlerton *db_type, uint32 flag)
 
2216
static inline bool ha_check_storage_engine_flag(const handlerton *db_type, uint32_t flag)
2222
2217
{
2223
2218
  return db_type == NULL ? false : test(db_type->flags & flag);
2224
2219
}
2237
2232
int ha_finalize_handlerton(st_plugin_int *plugin);
2238
2233
 
2239
2234
TYPELIB *ha_known_exts(void);
2240
 
int ha_panic(enum ha_panic_function flag);
2241
2235
void ha_close_connection(THD* thd);
2242
2236
bool ha_flush_logs(handlerton *db_type);
2243
2237
void ha_drop_database(char* path);