Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

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

1 files changed, 702 insertions, 0 deletions

diff --git a/storage/perfschema/table_helper.h b/storage/perfschema/table_helper.h
new file mode 100644
index 00000000..3ce74648
--- /dev/null
+++ b/storage/perfschema/table_helper.h
@@ -0,0 +1,702 @@
+/* Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License, version 2.0,
+  as published by the Free Software Foundation.
+
+  This program is also distributed with certain software (including
+  but not limited to OpenSSL) that is licensed under separate terms,
+  as designated in a particular file or component or in included license
+  documentation.  The authors of MySQL hereby grant you an additional
+  permission to link the program and your derivative works with the
+  separately licensed software that they have included with MySQL.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License, version 2.0, for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335  USA */
+
+#ifndef PFS_TABLE_HELPER_H
+#define PFS_TABLE_HELPER_H
+
+#include "pfs_column_types.h"
+#include "pfs_stat.h"
+#include "pfs_timer.h"
+#include "pfs_engine_table.h"
+#include "pfs_instr_class.h"
+#include "pfs_digest.h"
+
+/*
+  Write MD5 hash value in a string to be used
+  as DIGEST for the statement.
+*/
+#define MD5_HASH_TO_STRING(_hash, _str)                    \
+  sprintf(_str, "%02x%02x%02x%02x%02x%02x%02x%02x"         \
+                "%02x%02x%02x%02x%02x%02x%02x%02x",        \
+          _hash[0], _hash[1], _hash[2], _hash[3],          \
+          _hash[4], _hash[5], _hash[6], _hash[7],          \
+          _hash[8], _hash[9], _hash[10], _hash[11],        \
+          _hash[12], _hash[13], _hash[14], _hash[15])
+
+#define MD5_HASH_TO_STRING_LENGTH 32
+
+struct PFS_host;
+struct PFS_user;
+struct PFS_account;
+struct PFS_object_name;
+struct PFS_program;
+class System_variable;
+class Status_variable;
+
+/**
+  @file storage/perfschema/table_helper.h
+  Performance schema table helpers (declarations).
+*/
+
+/**
+  @addtogroup Performance_schema_tables
+  @{
+*/
+
+/** Namespace, internal views used within table setup_instruments. */
+struct PFS_instrument_view_constants
+{
+  static const uint FIRST_VIEW= 1;
+  static const uint VIEW_MUTEX= 1;
+  static const uint VIEW_RWLOCK= 2;
+  static const uint VIEW_COND= 3;
+  static const uint VIEW_FILE= 4;
+  static const uint VIEW_TABLE= 5;
+  static const uint VIEW_SOCKET= 6;
+  static const uint VIEW_IDLE= 7;
+  static const uint VIEW_METADATA= 8;
+  static const uint LAST_VIEW= 8;
+};
+
+/** Namespace, internal views used within object summaries. */
+struct PFS_object_view_constants
+{
+  static const uint FIRST_VIEW= 1;
+  static const uint VIEW_TABLE= 1;
+  static const uint VIEW_PROGRAM= 2;
+  static const uint LAST_VIEW= 2;
+};
+
+/** Row fragment for column HOST. */
+struct PFS_host_row
+{
+  /** Column HOST. */
+  char m_hostname[HOSTNAME_LENGTH];
+  /** Length in bytes of @c m_hostname. */
+  uint m_hostname_length;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_host *pfs);
+  /** Set a table field from the row. */
+  void set_field(Field *f);
+};
+
+/** Row fragment for column USER. */
+struct PFS_user_row
+{
+  /** Column USER. */
+  char m_username[USERNAME_LENGTH];
+  /** Length in bytes of @c m_username. */
+  uint m_username_length;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_user *pfs);
+  /** Set a table field from the row. */
+  void set_field(Field *f);
+};
+
+/** Row fragment for columns USER, HOST. */
+struct PFS_account_row
+{
+  /** Column USER. */
+  char m_username[USERNAME_LENGTH];
+  /** Length in bytes of @c m_username. */
+  uint m_username_length;
+  /** Column HOST. */
+  char m_hostname[HOSTNAME_LENGTH];
+  /** Length in bytes of @c m_hostname. */
+  uint m_hostname_length;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_account *pfs);
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+/** Row fragment for columns DIGEST, DIGEST_TEXT. */
+struct PFS_digest_row
+{
+  /** Column SCHEMA_NAME. */
+  char m_schema_name[NAME_LEN];
+  /** Length in bytes of @c m_schema_name. */
+  uint m_schema_name_length;
+  /** Column DIGEST. */
+  char m_digest[COL_DIGEST_SIZE];
+  /** Length in bytes of @c m_digest. */
+  uint m_digest_length;
+  /** Column DIGEST_TEXT. */
+  String m_digest_text;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_statements_digest_stat*);
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+/** Row fragment for column EVENT_NAME. */
+struct PFS_event_name_row
+{
+  /** Column EVENT_NAME. */
+  const char *m_name;
+  /** Length in bytes of @c m_name. */
+  uint m_name_length;
+
+  /** Build a row from a memory buffer. */
+  inline void make_row(PFS_instr_class *pfs)
+  {
+    m_name= pfs->m_name;
+    m_name_length= pfs->m_name_length;
+  }
+
+  /** Set a table field from the row. */
+  inline void set_field(Field *f)
+  {
+    PFS_engine_table::set_field_varchar_utf8(f, m_name, m_name_length);
+  }
+};
+
+/** Row fragment for columns OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME. */
+struct PFS_object_row
+{
+  /** Column OBJECT_TYPE. */
+  enum_object_type m_object_type;
+  /** Column SCHEMA_NAME. */
+  char m_schema_name[NAME_LEN];
+  /** Length in bytes of @c m_schema_name. */
+  uint m_schema_name_length;
+  /** Column OBJECT_NAME. */
+  char m_object_name[NAME_LEN];
+  /** Length in bytes of @c m_object_name. */
+  uint m_object_name_length;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_table_share *pfs);
+  int make_row(PFS_program *pfs);
+  int make_row(const MDL_key *pfs);
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+  void set_nullable_field(uint index, Field *f);
+};
+
+/** Row fragment for columns OBJECT_TYPE, SCHEMA_NAME, OBJECT_NAME, INDEX_NAME. */
+struct PFS_index_row
+{
+  PFS_object_row m_object_row;
+  /** Column INDEX_NAME. */
+  char m_index_name[NAME_LEN];
+  /** Length in bytes of @c m_index_name. */
+  uint m_index_name_length;
+
+  /** Build a row from a memory buffer. */
+  int make_row(PFS_table_share *pfs, PFS_table_share_index *pfs_index,
+               uint table_index);
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+/** Row fragment for single statistics columns (COUNT, SUM, MIN, AVG, MAX) */
+struct PFS_stat_row
+{
+  /** Column COUNT_STAR. */
+  ulonglong m_count;
+  /** Column SUM_TIMER_WAIT. */
+  ulonglong m_sum;
+  /** Column MIN_TIMER_WAIT. */
+  ulonglong m_min;
+  /** Column AVG_TIMER_WAIT. */
+  ulonglong m_avg;
+  /** Column MAX_TIMER_WAIT. */
+  ulonglong m_max;
+
+  inline void reset()
+  {
+    m_count= 0;
+    m_sum= 0;
+    m_min= 0;
+    m_avg= 0;
+    m_max= 0;
+  }
+
+  /** Build a row with timer fields from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_single_stat *stat)
+  {
+    m_count= stat->m_count;
+
+    if ((m_count != 0) && stat->has_timed_stats())
+    {
+      m_sum= normalizer->wait_to_pico(stat->m_sum);
+      m_min= normalizer->wait_to_pico(stat->m_min);
+      m_max= normalizer->wait_to_pico(stat->m_max);
+      m_avg= normalizer->wait_to_pico(stat->m_sum / m_count);
+    }
+    else
+    {
+      m_sum= 0;
+      m_min= 0;
+      m_avg= 0;
+      m_max= 0;
+    }
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f)
+  {
+    switch (index)
+    {
+      case 0: /* COUNT */
+        PFS_engine_table::set_field_ulonglong(f, m_count);
+        break;
+      case 1: /* SUM */
+        PFS_engine_table::set_field_ulonglong(f, m_sum);
+        break;
+      case 2: /* MIN */
+        PFS_engine_table::set_field_ulonglong(f, m_min);
+        break;
+      case 3: /* AVG */
+        PFS_engine_table::set_field_ulonglong(f, m_avg);
+        break;
+      case 4: /* MAX */
+        PFS_engine_table::set_field_ulonglong(f, m_max);
+        break;
+      default:
+        DBUG_ASSERT(false);
+    }
+  }
+};
+
+/** Row fragment for timer and byte count stats. Corresponds to PFS_byte_stat */
+struct PFS_byte_stat_row
+{
+  PFS_stat_row m_waits;
+  ulonglong    m_bytes;
+
+  /** Build a row with timer and byte count fields from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_byte_stat *stat)
+  {
+    m_waits.set(normalizer, stat);
+    m_bytes= stat->m_bytes;
+  }
+};
+
+/** Row fragment for table io statistics columns. */
+struct PFS_table_io_stat_row
+{
+  PFS_stat_row m_all;
+  PFS_stat_row m_all_read;
+  PFS_stat_row m_all_write;
+  PFS_stat_row m_fetch;
+  PFS_stat_row m_insert;
+  PFS_stat_row m_update;
+  PFS_stat_row m_delete;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_table_io_stat *stat)
+  {
+    PFS_single_stat all_read;
+    PFS_single_stat all_write;
+    PFS_single_stat all;
+
+    m_fetch.set(normalizer, & stat->m_fetch);
+
+    all_read.aggregate(& stat->m_fetch);
+
+    m_insert.set(normalizer, & stat->m_insert);
+    m_update.set(normalizer, & stat->m_update);
+    m_delete.set(normalizer, & stat->m_delete);
+
+    all_write.aggregate(& stat->m_insert);
+    all_write.aggregate(& stat->m_update);
+    all_write.aggregate(& stat->m_delete);
+
+    all.aggregate(& all_read);
+    all.aggregate(& all_write);
+
+    m_all_read.set(normalizer, & all_read);
+    m_all_write.set(normalizer, & all_write);
+    m_all.set(normalizer, & all);
+  }
+};
+
+/** Row fragment for table lock statistics columns. */
+struct PFS_table_lock_stat_row
+{
+  PFS_stat_row m_all;
+  PFS_stat_row m_all_read;
+  PFS_stat_row m_all_write;
+  PFS_stat_row m_read_normal;
+  PFS_stat_row m_read_with_shared_locks;
+  PFS_stat_row m_read_high_priority;
+  PFS_stat_row m_read_no_insert;
+  PFS_stat_row m_read_external;
+  PFS_stat_row m_write_allow_write;
+  PFS_stat_row m_write_concurrent_insert;
+  PFS_stat_row m_write_delayed;
+  PFS_stat_row m_write_low_priority;
+  PFS_stat_row m_write_normal;
+  PFS_stat_row m_write_external;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_table_lock_stat *stat)
+  {
+    PFS_single_stat all_read;
+    PFS_single_stat all_write;
+    PFS_single_stat all;
+
+    m_read_normal.set(normalizer, & stat->m_stat[PFS_TL_READ]);
+    m_read_with_shared_locks.set(normalizer, & stat->m_stat[PFS_TL_READ_WITH_SHARED_LOCKS]);
+    m_read_high_priority.set(normalizer, & stat->m_stat[PFS_TL_READ_HIGH_PRIORITY]);
+    m_read_no_insert.set(normalizer, & stat->m_stat[PFS_TL_READ_NO_INSERT]);
+    m_read_external.set(normalizer, & stat->m_stat[PFS_TL_READ_EXTERNAL]);
+
+    all_read.aggregate(& stat->m_stat[PFS_TL_READ]);
+    all_read.aggregate(& stat->m_stat[PFS_TL_READ_WITH_SHARED_LOCKS]);
+    all_read.aggregate(& stat->m_stat[PFS_TL_READ_HIGH_PRIORITY]);
+    all_read.aggregate(& stat->m_stat[PFS_TL_READ_NO_INSERT]);
+    all_read.aggregate(& stat->m_stat[PFS_TL_READ_EXTERNAL]);
+
+    m_write_allow_write.set(normalizer, & stat->m_stat[PFS_TL_WRITE_ALLOW_WRITE]);
+    m_write_concurrent_insert.set(normalizer, & stat->m_stat[PFS_TL_WRITE_CONCURRENT_INSERT]);
+    m_write_delayed.set(normalizer, & stat->m_stat[PFS_TL_WRITE_DELAYED]);
+    m_write_low_priority.set(normalizer, & stat->m_stat[PFS_TL_WRITE_LOW_PRIORITY]);
+    m_write_normal.set(normalizer, & stat->m_stat[PFS_TL_WRITE]);
+    m_write_external.set(normalizer, & stat->m_stat[PFS_TL_WRITE_EXTERNAL]);
+
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_ALLOW_WRITE]);
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_CONCURRENT_INSERT]);
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_DELAYED]);
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_LOW_PRIORITY]);
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE]);
+    all_write.aggregate(& stat->m_stat[PFS_TL_WRITE_EXTERNAL]);
+
+    all.aggregate(& all_read);
+    all.aggregate(& all_write);
+
+    m_all_read.set(normalizer, & all_read);
+    m_all_write.set(normalizer, & all_write);
+    m_all.set(normalizer, & all);
+  }
+};
+
+/** Row fragment for stage statistics columns. */
+struct PFS_stage_stat_row
+{
+  PFS_stat_row m_timer1_row;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_stage_stat *stat)
+  {
+    m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f)
+  {
+     m_timer1_row.set_field(index, f);
+  }
+};
+
+/** Row fragment for statement statistics columns. */
+struct PFS_statement_stat_row
+{
+  PFS_stat_row m_timer1_row;
+  ulonglong m_error_count;
+  ulonglong m_warning_count;
+  ulonglong m_rows_affected;
+  ulonglong m_lock_time;
+  ulonglong m_rows_sent;
+  ulonglong m_rows_examined;
+  ulonglong m_created_tmp_disk_tables;
+  ulonglong m_created_tmp_tables;
+  ulonglong m_select_full_join;
+  ulonglong m_select_full_range_join;
+  ulonglong m_select_range;
+  ulonglong m_select_range_check;
+  ulonglong m_select_scan;
+  ulonglong m_sort_merge_passes;
+  ulonglong m_sort_range;
+  ulonglong m_sort_rows;
+  ulonglong m_sort_scan;
+  ulonglong m_no_index_used;
+  ulonglong m_no_good_index_used;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_statement_stat *stat)
+  {
+    if (stat->m_timer1_stat.m_count != 0)
+    {
+      m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+
+      m_error_count= stat->m_error_count;
+      m_warning_count= stat->m_warning_count;
+      m_lock_time= stat->m_lock_time * MICROSEC_TO_PICOSEC;
+      m_rows_affected= stat->m_rows_affected;
+      m_rows_sent= stat->m_rows_sent;
+      m_rows_examined= stat->m_rows_examined;
+      m_created_tmp_disk_tables= stat->m_created_tmp_disk_tables;
+      m_created_tmp_tables= stat->m_created_tmp_tables;
+      m_select_full_join= stat->m_select_full_join;
+      m_select_full_range_join= stat->m_select_full_range_join;
+      m_select_range= stat->m_select_range;
+      m_select_range_check= stat->m_select_range_check;
+      m_select_scan= stat->m_select_scan;
+      m_sort_merge_passes= stat->m_sort_merge_passes;
+      m_sort_range= stat->m_sort_range;
+      m_sort_rows= stat->m_sort_rows;
+      m_sort_scan= stat->m_sort_scan;
+      m_no_index_used= stat->m_no_index_used;
+      m_no_good_index_used= stat->m_no_good_index_used;
+    }
+    else
+    {
+      m_timer1_row.reset();
+
+      m_error_count= 0;
+      m_warning_count= 0;
+      m_lock_time= 0;
+      m_rows_affected= 0;
+      m_rows_sent= 0;
+      m_rows_examined= 0;
+      m_created_tmp_disk_tables= 0;
+      m_created_tmp_tables= 0;
+      m_select_full_join= 0;
+      m_select_full_range_join= 0;
+      m_select_range= 0;
+      m_select_range_check= 0;
+      m_select_scan= 0;
+      m_sort_merge_passes= 0;
+      m_sort_range= 0;
+      m_sort_rows= 0;
+      m_sort_scan= 0;
+      m_no_index_used= 0;
+      m_no_good_index_used= 0;
+    }
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+/** Row fragment for stored program statistics. */
+struct PFS_sp_stat_row
+{
+  PFS_stat_row m_timer1_row;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_sp_stat *stat)
+  {
+    m_timer1_row.set(normalizer, & stat->m_timer1_stat);
+  }
+
+  /** Set a table field from the row. */
+  inline void set_field(uint index, Field *f)
+  {
+    m_timer1_row.set_field(index, f);
+  }
+};
+
+/** Row fragment for transaction statistics columns. */
+struct PFS_transaction_stat_row
+{
+  PFS_stat_row m_timer1_row;
+  PFS_stat_row m_read_write_row;
+  PFS_stat_row m_read_only_row;
+  ulonglong m_savepoint_count;
+  ulonglong m_rollback_to_savepoint_count;
+  ulonglong m_release_savepoint_count;
+
+  /** Build a row from a memory buffer. */
+  inline void set(time_normalizer *normalizer, const PFS_transaction_stat *stat)
+  {
+    /* Combine read write/read only stats */
+    PFS_single_stat all;
+    all.aggregate(&stat->m_read_only_stat);
+    all.aggregate(&stat->m_read_write_stat);
+
+    m_timer1_row.set(normalizer, &all);
+    m_read_write_row.set(normalizer, &stat->m_read_write_stat);
+    m_read_only_row.set(normalizer, &stat->m_read_only_stat);
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+/** Row fragment for connection statistics. */
+struct PFS_connection_stat_row
+{
+  ulonglong m_current_connections;
+  ulonglong m_total_connections;
+
+  inline void set(const PFS_connection_stat *stat)
+  {
+    m_current_connections= stat->m_current_connections;
+    m_total_connections= stat->m_total_connections;
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+void set_field_object_type(Field *f, enum_object_type object_type);
+void set_field_lock_type(Field *f, PFS_TL_LOCK_TYPE lock_type);
+void set_field_mdl_type(Field *f, opaque_mdl_type mdl_type, bool backup);
+void set_field_mdl_duration(Field *f, opaque_mdl_duration mdl_duration);
+void set_field_mdl_status(Field *f, opaque_mdl_status mdl_status);
+void set_field_isolation_level(Field *f, enum_isolation_level iso_level);
+void set_field_xa_state(Field *f, enum_xa_transaction_state xa_state);
+
+/** Row fragment for socket io statistics columns. */
+struct PFS_socket_io_stat_row
+{
+  PFS_byte_stat_row m_read;
+  PFS_byte_stat_row m_write;
+  PFS_byte_stat_row m_misc;
+  PFS_byte_stat_row m_all;
+
+  inline void set(time_normalizer *normalizer, const PFS_socket_io_stat *stat)
+  {
+    PFS_byte_stat all;
+
+    m_read.set(normalizer, &stat->m_read);
+    m_write.set(normalizer, &stat->m_write);
+    m_misc.set(normalizer, &stat->m_misc);
+
+    /* Combine stats for all operations */
+    all.aggregate(&stat->m_read);
+    all.aggregate(&stat->m_write);
+    all.aggregate(&stat->m_misc);
+
+    m_all.set(normalizer, &all);
+  }
+};
+
+/** Row fragment for file io statistics columns. */
+struct PFS_file_io_stat_row
+{
+  PFS_byte_stat_row m_read;
+  PFS_byte_stat_row m_write;
+  PFS_byte_stat_row m_misc;
+  PFS_byte_stat_row m_all;
+
+  inline void set(time_normalizer *normalizer, const PFS_file_io_stat *stat)
+  {
+    PFS_byte_stat all;
+
+    m_read.set(normalizer, &stat->m_read);
+    m_write.set(normalizer, &stat->m_write);
+    m_misc.set(normalizer, &stat->m_misc);
+
+    /* Combine stats for all operations */
+    all.aggregate(&stat->m_read);
+    all.aggregate(&stat->m_write);
+    all.aggregate(&stat->m_misc);
+
+    m_all.set(normalizer, &all);
+  }
+};
+
+/** Row fragment for memory statistics columns. */
+struct PFS_memory_stat_row
+{
+  PFS_memory_stat m_stat;
+
+  /** Build a row from a memory buffer. */
+  inline void set(const PFS_memory_stat *stat)
+  {
+    m_stat= *stat;
+  }
+
+  /** Set a table field from the row. */
+  void set_field(uint index, Field *f);
+};
+
+struct PFS_variable_name_row
+{
+public:
+  PFS_variable_name_row()
+  {
+    m_str[0]= '\0';
+    m_length= 0;
+  }
+
+  void make_row(const char* str, size_t length);
+
+  char m_str[NAME_CHAR_LEN+1];
+  uint m_length;
+};
+
+struct PFS_variable_value_row
+{
+public:
+  /** Set the row from a status variable. */
+  void make_row(const Status_variable *var);
+
+  /** Set the row from a system variable. */
+  void make_row(const System_variable *var);
+
+  /** Set a table field from the row. */
+  void set_field(Field *f);
+
+private:
+  void make_row(const CHARSET_INFO *cs, const char* str, size_t length);
+
+  char m_str[1024];
+  uint m_length;
+  const CHARSET_INFO *m_charset;
+};
+
+struct PFS_user_variable_value_row
+{
+public:
+  PFS_user_variable_value_row()
+    : m_value(NULL), m_value_length(0)
+  {}
+
+  PFS_user_variable_value_row(const PFS_user_variable_value_row& rhs)
+  {
+    make_row(rhs.m_value, rhs.m_value_length);
+  }
+
+  ~PFS_user_variable_value_row()
+  {
+    clear();
+  }
+
+  void make_row(const char* val, size_t length);
+
+  const char *get_value() const
+  { return m_value; }
+
+  size_t get_value_length() const
+  { return m_value_length; }
+
+  void clear();
+
+private:
+  char *m_value;
+  size_t m_value_length;
+};
+
+/** @} */
+
+#endif
+