pfs_engine_table.h

Go to the documentation of this file.

/* Copyright (c) 2008, 2011, 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 as published by
  the Free Software Foundation; version 2 of the License.

  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 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,
  51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */

#ifndef PFS_ENGINE_TABLE_H
#define PFS_ENGINE_TABLE_H

#include "sql_acl.h"                            /* struct ACL_* */
#include "pfs_instr_class.h"
class Field;
struct PFS_engine_table_share;
struct time_normalizer;

class PFS_engine_table
{
public:
  static const PFS_engine_table_share*
    find_engine_table_share(const char *name);

  int read_row(TABLE *table, unsigned char *buf, Field **fields);

  int update_row(TABLE *table, const unsigned char *old_buf,
                 unsigned char *new_buf, Field **fields);

  int delete_row(TABLE *table, const unsigned char *buf, Field **fields);

  virtual int rnd_init(bool scan){return 0;};

  virtual int rnd_next(void)= 0;
  virtual int rnd_pos(const void *pos)= 0;

  void get_position(void *ref);
  void set_position(const void *ref);
  virtual void reset_position(void)= 0;

  void get_normalizer(PFS_instr_class *instr_class);

  virtual ~PFS_engine_table()
  {}

  static void set_field_ulong(Field *f, ulong value);
  static void set_field_ulonglong(Field *f, ulonglong value);
  static void set_field_char_utf8(Field *f, const char *str, uint len);
  static void set_field_varchar_utf8(Field *f, const char *str, uint len);
  static void set_field_longtext_utf8(Field *f, const char *str, uint len);
  static void set_field_enum(Field *f, ulonglong value);
  static void set_field_timestamp(Field *f, ulonglong value);
  static ulonglong get_field_enum(Field *f);
  static String *get_field_char_utf8(Field *f, String *val);
  static String *get_field_varchar_utf8(Field *f, String *val);

protected:
  virtual int read_row_values(TABLE *table, unsigned char *buf,
                              Field **fields, bool read_all)= 0;

  virtual int update_row_values(TABLE *table, const unsigned char *old_buf,
                                unsigned char *new_buf, Field **fields);

  virtual int delete_row_values(TABLE *table, const unsigned char *buf,
                                Field **fields);

  PFS_engine_table(const PFS_engine_table_share *share, void *pos)
    : m_share_ptr(share), m_pos_ptr(pos),
      m_normalizer(NULL), m_class_type(PFS_CLASS_NONE)
  {}

  const PFS_engine_table_share *m_share_ptr;
  void *m_pos_ptr;
  time_normalizer *m_normalizer;
  enum PFS_class_type m_class_type;
};

typedef PFS_engine_table* (*pfs_open_table_t)(void);
typedef int (*pfs_write_row_t)(TABLE *table,
                               unsigned char *buf, Field **fields);
typedef int (*pfs_delete_all_rows_t)(void);
typedef ha_rows (*pfs_get_row_count_t)(void);

struct PFS_engine_table_share
{
  static void check_all_tables(THD *thd);
  void check_one_table(THD *thd);
  static void init_all_locks(void);
  static void delete_all_locks(void);
  ha_rows get_row_count(void) const;
  int write_row(TABLE *table, unsigned char *buf, Field **fields) const;

  LEX_STRING m_name;
  const ACL_internal_table_access *m_acl;
  pfs_open_table_t m_open_table;
  pfs_write_row_t m_write_row;
  pfs_delete_all_rows_t m_delete_all_rows;
  pfs_get_row_count_t m_get_row_count;
  ha_rows m_records;
  uint m_ref_length;
  THR_LOCK *m_thr_lock_ptr;
  TABLE_FIELD_DEF *m_field_def;
  bool m_checked;
};

class PFS_readonly_acl : public ACL_internal_table_access
{
public:
  PFS_readonly_acl()
  {}

  ~PFS_readonly_acl()
  {}

  virtual ACL_internal_access_result check(ulong want_access, ulong *save_priv) const;
};

extern PFS_readonly_acl pfs_readonly_acl;

class PFS_truncatable_acl : public ACL_internal_table_access
{
public:
  PFS_truncatable_acl()
  {}

  ~PFS_truncatable_acl()
  {}

  ACL_internal_access_result check(ulong want_access, ulong *save_priv) const;
};

extern PFS_truncatable_acl pfs_truncatable_acl;

class PFS_updatable_acl : public ACL_internal_table_access
{
public:
  PFS_updatable_acl()
  {}

  ~PFS_updatable_acl()
  {}

  ACL_internal_access_result check(ulong want_access, ulong *save_priv) const;
};

extern PFS_updatable_acl pfs_updatable_acl;

class PFS_editable_acl : public ACL_internal_table_access
{
public:
  PFS_editable_acl()
  {}

  ~PFS_editable_acl()
  {}

  ACL_internal_access_result check(ulong want_access, ulong *save_priv) const;
};

extern PFS_editable_acl pfs_editable_acl;

class PFS_unknown_acl : public ACL_internal_table_access
{
public:
  PFS_unknown_acl()
  {}

  ~PFS_unknown_acl()
  {}

  ACL_internal_access_result check(ulong want_access, ulong *save_priv) const;
};

extern PFS_unknown_acl pfs_unknown_acl;

struct PFS_simple_index
{
  uint m_index;

  PFS_simple_index(uint index)
    : m_index(index)
  {}

  void set_at(const struct PFS_simple_index *other)
  { m_index= other->m_index; }

  void set_after(const struct PFS_simple_index *other)
  { m_index= other->m_index + 1; }

  void next(void)
  { m_index++; }
};

struct PFS_double_index
{
  uint m_index_1;
  uint m_index_2;

  PFS_double_index(uint index_1, uint index_2)
    : m_index_1(index_1), m_index_2(index_2)
  {}

  void set_at(const struct PFS_double_index *other)
  {
    m_index_1= other->m_index_1;
    m_index_2= other->m_index_2;
  }

  void set_after(const struct PFS_double_index *other)
  {
    m_index_1= other->m_index_1;
    m_index_2= other->m_index_2 + 1;
  }
};

struct PFS_triple_index
{
  uint m_index_1;
  uint m_index_2;
  uint m_index_3;

  PFS_triple_index(uint index_1, uint index_2, uint index_3)
    : m_index_1(index_1), m_index_2(index_2), m_index_3(index_3)
  {}

  void set_at(const struct PFS_triple_index *other)
  {
    m_index_1= other->m_index_1;
    m_index_2= other->m_index_2;
    m_index_3= other->m_index_3;
  }

  void set_after(const struct PFS_triple_index *other)
  {
    m_index_1= other->m_index_1;
    m_index_2= other->m_index_2;
    m_index_3= other->m_index_3 + 1;
  }
};

bool pfs_show_status(handlerton *hton, THD *thd,
                     stat_print_fn *print, enum ha_stat_type stat);

#endif