Merging upstream version 1:11.4.2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 99 insertions, 50 deletions

diff --git a/storage/archive/archive_reader.c b/storage/archive/archive_reader.c
index 0e02127e..85637a04 100644
--- a/storage/archive/archive_reader.c
+++ b/storage/archive/archive_reader.c
@@ -26,7 +26,7 @@
 #define BUFFER_LEN 1024
 #define ARCHIVE_ROW_HEADER_SIZE 4
 
-#define SHOW_VERSION "0.1"
+#define VER "0.1"
 
 static void get_options(int *argc,char * * *argv);
 static void print_version(void);
@@ -400,12 +400,6 @@ static void usage(void)
   my_print_help(my_long_options);
 }
 
-static void print_version(void)
-{
-  printf("%s  Ver %s Distrib %s, for %s (%s)\n", my_progname, SHOW_VERSION,
-         MYSQL_SERVER_VERSION, SYSTEM_TYPE, MACHINE_TYPE);
-}
-
 static void get_options(int *argc, char ***argv)
 {
   load_defaults_or_exit("my", load_default_groups, argc, argv);
diff --git a/storage/archive/ha_archive.cc b/storage/archive/ha_archive.cc
index 1ee1f071..03269625 100644
--- a/storage/archive/ha_archive.cc
+++ b/storage/archive/ha_archive.cc
@@ -132,7 +132,8 @@ extern "C" PSI_file_key arch_key_file_data;
 static handler *archive_create_handler(handlerton *hton, 
                                        TABLE_SHARE *table, 
                                        MEM_ROOT *mem_root);
-int archive_discover(handlerton *hton, THD* thd, TABLE_SHARE *share);
+static int archive_discover(handlerton *hton, THD* thd, TABLE_SHARE *share);
+static void archive_update_optimizer_costs(OPTIMIZER_COSTS *costs);
 
 /*
   Number of rows that will force a bulk insert.
@@ -205,6 +206,7 @@ static const char *ha_archive_exts[] = {
   NullS
 };
 
+
 int archive_db_init(void *p)
 {
   DBUG_ENTER("archive_db_init");
@@ -217,10 +219,10 @@ int archive_db_init(void *p)
   archive_hton= (handlerton *)p;
   archive_hton->db_type= DB_TYPE_ARCHIVE_DB;
   archive_hton->create= archive_create_handler;
-  archive_hton->flags= HTON_NO_FLAGS;
   archive_hton->discover_table= archive_discover;
   archive_hton->tablefile_extensions= ha_archive_exts;
-
+  archive_hton->update_optimizer_costs= archive_update_optimizer_costs;
+  archive_hton->flags= HTON_NO_FLAGS;
   DBUG_RETURN(0);
 }
 
@@ -270,7 +272,7 @@ ha_archive::ha_archive(handlerton *hton, TABLE_SHARE *table_arg)
 /* Stack size 50264 with clang */
 PRAGMA_DISABLE_CHECK_STACK_FRAME
 
-int archive_discover(handlerton *hton, THD* thd, TABLE_SHARE *share)
+static int archive_discover(handlerton *hton, THD* thd, TABLE_SHARE *share)
 {
   DBUG_ENTER("archive_discover");
   DBUG_PRINT("archive_discover", ("db: '%s'  name: '%s'", share->db.str,
@@ -1105,6 +1107,54 @@ int ha_archive::index_init(uint keynr, bool sorted)
   DBUG_RETURN(0);
 }
 
+#define ARCHIVE_DECOMPRESS_TIME 0.081034543792841 // See optimizer_costs.txt
+
+static void archive_update_optimizer_costs(OPTIMIZER_COSTS *costs)
+{
+  costs->disk_read_ratio= 0.20;     // Assume 80 % of data is cached by system
+  costs->row_lookup_cost= 0;        // See rnd_pos_time
+  costs->key_lookup_cost= 0;        // See key_read_time
+  costs->key_next_find_cost= 0;     // Only unique indexes
+  costs->index_block_copy_cost= 0;
+}
+
+
+IO_AND_CPU_COST ha_archive::scan_time()
+{
+  IO_AND_CPU_COST cost;
+  ulonglong blocks;
+  DBUG_ENTER("ha_archive::scan_time");
+
+  blocks= stats.data_file_length / IO_SIZE;
+  cost.io= 0;                                   // No cache
+  cost.cpu= (blocks * DISK_READ_COST * DISK_READ_RATIO +
+             blocks*  ARCHIVE_DECOMPRESS_TIME);
+  DBUG_RETURN(cost);
+}
+
+
+IO_AND_CPU_COST ha_archive::keyread_time(uint index, ulong ranges, ha_rows rows,
+                                         ulonglong blocks)
+{
+  IO_AND_CPU_COST cost= scan_time();
+  /*
+    As these is an unique indexe, assume that we have to scan half the file for
+    each range to find the row.
+  */
+  cost.cpu= cost.cpu * ranges / 2;
+  return cost;
+}
+
+
+IO_AND_CPU_COST ha_archive::rnd_pos_time(ha_rows rows)
+{
+  IO_AND_CPU_COST cost;
+  /* We have to do one azseek() for each row */
+  cost.io= rows2double(rows);
+  cost.cpu= rows * (DISK_READ_COST * DISK_READ_RATIO + ARCHIVE_DECOMPRESS_TIME);
+  return cost;
+}
+
 
 /*
   No indexes, so if we get a request for an index search since we tell
@@ -1129,8 +1179,6 @@ int ha_archive::index_read_idx(uchar *buf, uint index, const uchar *key,
   current_k_offset= mkey->key_part->offset;
   current_key= key;
   current_key_len= key_len;
-
-
   DBUG_ENTER("ha_archive::index_read_idx");
 
   rc= rnd_init(TRUE);
@@ -1980,4 +2028,3 @@ maria_declare_plugin(archive)
   MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
 }
 maria_declare_plugin_end;
-
diff --git a/storage/archive/ha_archive.h b/storage/archive/ha_archive.h
index 2e03ac63..8a6c5922 100644
--- a/storage/archive/ha_archive.h
+++ b/storage/archive/ha_archive.h
@@ -88,8 +88,8 @@ class ha_archive final : public handler
 public:
   ha_archive(handlerton *hton, TABLE_SHARE *table_arg);
   ~ha_archive() = default;
-  const char *index_type(uint inx) { return "NONE"; }
-  ulonglong table_flags() const
+  const char *index_type(uint inx) override { return "NONE"; }
+  ulonglong table_flags() const override
   {
     return (HA_NO_TRANSACTIONS | HA_REC_NOT_IN_SEQ | HA_CAN_BIT_FIELD |
             HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
@@ -97,66 +97,74 @@ public:
             HA_HAS_RECORDS | HA_CAN_REPAIR | HA_SLOW_RND_POS |
             HA_FILE_BASED | HA_CAN_INSERT_DELAYED | HA_CAN_GEOMETRY);
   }
-  ulong index_flags(uint idx, uint part, bool all_parts) const
+  ulong index_flags(uint idx, uint part, bool all_parts) const override
   {
     return HA_ONLY_WHOLE_INDEX;
   }
   virtual void get_auto_increment(ulonglong offset, ulonglong increment,
                                   ulonglong nb_desired_values,
                                   ulonglong *first_value,
-                                  ulonglong *nb_reserved_values);
-  uint max_supported_keys()          const { return 1; }
-  uint max_supported_key_length()    const { return sizeof(ulonglong); }
-  uint max_supported_key_part_length() const { return sizeof(ulonglong); }
-  ha_rows records() { return share->rows_recorded; }
-  int index_init(uint keynr, bool sorted);
+                                  ulonglong *nb_reserved_values) override;
+  uint max_supported_keys() const override { return 1; }
+  uint max_supported_key_length() const override { return sizeof(ulonglong); }
+  uint max_supported_key_part_length() const override
+    { return sizeof(ulonglong); }
+  ha_rows records() override { return share->rows_recorded; }
+  IO_AND_CPU_COST scan_time() override;
+  IO_AND_CPU_COST keyread_time(uint index, ulong ranges, ha_rows rows,
+                               ulonglong blocks) override;
+  IO_AND_CPU_COST rnd_pos_time(ha_rows rows) override;
+  int index_init(uint keynr, bool sorted) override;
   virtual int index_read(uchar * buf, const uchar * key,
-			 uint key_len, enum ha_rkey_function find_flag);
+			 uint key_len, enum ha_rkey_function find_flag)
+                         override;
   virtual int index_read_idx(uchar * buf, uint index, const uchar * key,
 			     uint key_len, enum ha_rkey_function find_flag);
-  int index_next(uchar * buf);
-  int open(const char *name, int mode, uint test_if_locked);
-  int close(void);
-  int write_row(const uchar * buf);
+  int index_next(uchar * buf) override;
+  int open(const char *name, int mode, uint test_if_locked) override;
+  int close(void) override;
+  int write_row(const uchar * buf) override;
   int real_write_row(const uchar *buf, azio_stream *writer);
-  int truncate();
-  int rnd_init(bool scan=1);
-  int rnd_next(uchar *buf);
-  int rnd_pos(uchar * buf, uchar *pos);
+  int truncate() override;
+  int rnd_init(bool scan=1) override;
+  int rnd_next(uchar *buf) override;
+  int rnd_pos(uchar * buf, uchar *pos) override;
   int get_row(azio_stream *file_to_read, uchar *buf);
   int get_row_version2(azio_stream *file_to_read, uchar *buf);
   int get_row_version3(azio_stream *file_to_read, uchar *buf);
   Archive_share *get_share(const char *table_name, int *rc);
   int init_archive_reader();
   // Always try auto_repair in case of HA_ERR_CRASHED_ON_USAGE
-  bool auto_repair(int error) const
+  bool auto_repair(int error) const override
   { return error == HA_ERR_CRASHED_ON_USAGE; }
   int read_data_header(azio_stream *file_to_read);
-  void position(const uchar *record);
-  int info(uint);
-  int extra(enum ha_extra_function operation);
-  void update_create_info(HA_CREATE_INFO *create_info);
-  int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
-  int optimize(THD* thd, HA_CHECK_OPT* check_opt);
-  int repair(THD* thd, HA_CHECK_OPT* check_opt);
-  int check_for_upgrade(HA_CHECK_OPT *check_opt);
-  void start_bulk_insert(ha_rows rows, uint flags);
-  int end_bulk_insert();
-  enum row_type get_row_type() const 
+  void position(const uchar *record) override;
+  int info(uint) override;
+  int extra(enum ha_extra_function operation) override;
+  void update_create_info(HA_CREATE_INFO *create_info) override;
+  int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info)
+    override;
+  int optimize(THD* thd, HA_CHECK_OPT* check_opt) override;
+  int repair(THD* thd, HA_CHECK_OPT* check_opt) override;
+  int check_for_upgrade(HA_CHECK_OPT *check_opt) override;
+  void start_bulk_insert(ha_rows rows, uint flags) override;
+  int end_bulk_insert() override;
+  enum row_type get_row_type() const override
   { 
     return ROW_TYPE_COMPRESSED;
   }
   THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
-                             enum thr_lock_type lock_type);
-  bool is_crashed() const;
-  int check(THD* thd, HA_CHECK_OPT* check_opt);
-  bool check_and_repair(THD *thd);
+                             enum thr_lock_type lock_type) override;
+  bool is_crashed() const override;
+  int check(THD* thd, HA_CHECK_OPT* check_opt) override;
+  bool check_and_repair(THD *thd) override;
   uint32 max_row_length(const uchar *buf);
   bool fix_rec_buff(unsigned int length);
   int unpack_row(azio_stream *file_to_read, uchar *record);
   unsigned int pack_row(const uchar *record, azio_stream *writer);
-  bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes);
-  int external_lock(THD *thd, int lock_type);
+  bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes)
+    override;
+  int external_lock(THD *thd, int lock_type) override;
 private:
   void flush_and_clear_pending_writes();
 };