sql_data_change.h

Go to the documentation of this file.

#ifndef SQL_DATA_CHANGE_INCLUDED
#define SQL_DATA_CHANGE_INCLUDED
/* Copyright (c) 2000, 2013, 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 */

#include "sql_list.h"
#include "my_base.h"
#include "my_bitmap.h"
#include "table.h"

enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_UPDATE };

class COPY_INFO: public Sql_alloc
{
public:
  class Statistics
  {
  public:
    Statistics() :
      records(0), deleted(0), updated(0), copied(0), error_count(0), touched(0)
    {}

    ha_rows records; 
    ha_rows deleted; 
    ha_rows updated; 
    ha_rows copied;  
    ha_rows error_count;
    ha_rows touched; /* Number of touched records */
  };

  enum operation_type { INSERT_OPERATION, UPDATE_OPERATION };

private:
  COPY_INFO(const COPY_INFO &other);            
  void operator=(COPY_INFO &);                  

  const operation_type m_optype;

  List<Item> *m_changed_columns;

  List<Item> *m_changed_columns2;


  const bool m_manage_defaults;
  MY_BITMAP *m_function_default_columns;

protected:

  enum enum_duplicates handle_duplicates;

  bool ignore;

  bool get_function_default_columns(TABLE *table);

  MY_BITMAP *get_cached_bitmap() const { return m_function_default_columns; }

public:
  Statistics stats;
  int escape_char, last_errno;
  List<Item> *update_values;

  COPY_INFO(operation_type optype,
            List<Item> *inserted_columns,
            bool manage_defaults,
            enum_duplicates duplicate_handling,
            bool ignore_errors) :
    m_optype(optype),
    m_changed_columns(inserted_columns),
    m_changed_columns2(NULL),
    m_manage_defaults(manage_defaults),
    m_function_default_columns(NULL),
    handle_duplicates(duplicate_handling),
    ignore(ignore_errors),
    stats(),
    escape_char(0),
    last_errno(0),
    update_values(NULL)
  {
    DBUG_ASSERT(optype == INSERT_OPERATION);
  }

  COPY_INFO(operation_type optype,
            List<Item> *inserted_columns,
            List<Item> *inserted_columns2,
            bool manage_defaults,
            enum_duplicates duplicates_handling,
            bool ignore_duplicates,
            int escape_character) :
    m_optype(optype),
    m_changed_columns(inserted_columns),
    m_changed_columns2(inserted_columns2),
    m_manage_defaults(manage_defaults),
    m_function_default_columns(NULL),
    handle_duplicates(duplicates_handling),
    ignore(ignore_duplicates),
    stats(),
    escape_char(escape_character),
    last_errno(0),
    update_values(NULL)
  {
    DBUG_ASSERT(optype == INSERT_OPERATION);
  }

  COPY_INFO(operation_type optype, List<Item> *fields, List<Item> *values) :
    m_optype(optype),
    m_changed_columns(fields),
    m_changed_columns2(NULL),
    m_manage_defaults(true),
    m_function_default_columns(NULL),
    handle_duplicates(DUP_ERROR),
    ignore(false),
    stats(),
    escape_char(0),
    last_errno(0),
    update_values(values)
  {
    DBUG_ASSERT(optype == UPDATE_OPERATION);
  }

  operation_type get_operation_type() const { return m_optype; }

  List<Item> *get_changed_columns() const { return m_changed_columns; }

  const List<Item> *get_changed_columns2() const { return m_changed_columns2; }

  bool get_manage_defaults() const { return m_manage_defaults; }

  enum_duplicates get_duplicate_handling() const { return handle_duplicates; }

  bool get_ignore_errors() const { return ignore; }

  virtual void set_function_defaults(TABLE *table);

  bool add_function_default_columns(TABLE *table, MY_BITMAP *columns)
  {
    if (get_function_default_columns(table))
      return true;
    bitmap_union(columns, m_function_default_columns);
    return false;
  }

  bool function_defaults_apply(const TABLE *table) const
  {
    DBUG_ASSERT(m_function_default_columns != NULL);
    return !bitmap_is_clear_all(m_function_default_columns);
  }

  bool function_defaults_apply_on_columns(MY_BITMAP *map)
  {
    DBUG_ASSERT(m_function_default_columns != NULL);
    return bitmap_is_overlapping(m_function_default_columns, map);
  }

  bool ignore_last_columns(TABLE *table, uint count);

  virtual ~COPY_INFO() {}
};


#endif // SQL_DATA_CHANGE_INCLUDED