item.h

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 *
 *  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, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */



#pragma once

#include <drizzled/dtcollation.h>
#include <drizzled/charset.h>
#include <drizzled/item_result.h>
#include <drizzled/memory/sql_alloc.h>
#include <drizzled/sql_list.h>
#include <drizzled/sql_string.h>

#include <drizzled/visibility.h>

namespace drizzled {

/*
  Analyzer function
    SYNOPSIS
      argp   in/out IN:  Analysis parameter
                    OUT: Parameter to be passed to the transformer

     RETURN
      true   Invoke the transformer
      false  Don't do it

*/
typedef bool (Item::*Item_analyzer) (unsigned char **argp);
typedef Item* (Item::*Item_transformer) (unsigned char *arg);
typedef void (*Cond_traverser) (const Item *item, void *arg);
typedef bool (Item::*Item_processor) (unsigned char *arg);

class DRIZZLED_API Item : public memory::SqlAlloc, boost::noncopyable
{
  /* Cache of the result of is_expensive(). */
  int8_t is_expensive_cache;
  virtual bool is_expensive_processor(unsigned char *arg);

public:

  enum Type
  {
    FIELD_ITEM= 0,
    FUNC_ITEM,
    SUM_FUNC_ITEM,
    STRING_ITEM,
    INT_ITEM,
    REAL_ITEM,
    NULL_ITEM,
    VARBIN_ITEM,
    COPY_STR_ITEM,
    FIELD_AVG_ITEM,
    DEFAULT_VALUE_ITEM,
    PROC_ITEM,
    COND_ITEM,
    REF_ITEM,
    FIELD_STD_ITEM,
    FIELD_VARIANCE_ITEM,
    INSERT_VALUE_ITEM,
    SUBSELECT_ITEM,
    ROW_ITEM, CACHE_ITEM,
    TYPE_HOLDER,
    PARAM_ITEM,
    BOOLEAN_ITEM,
    DECIMAL_ITEM
  };
  enum traverse_order
  {
    T_POSTFIX,
    T_PREFIX
  };
  enum cond_result
  {
    COND_UNDEF,
    COND_OK,
    COND_TRUE,
    COND_FALSE
  };

  String str_value;

  const char *name;

  uint32_t name_length;

  Item *next;
  uint32_t max_length;

  int8_t marker;
  uint8_t decimals;
  bool fixed; 
  bool maybe_null; 
  bool null_value; 
  bool unsigned_flag;

  bool is_unsigned() const
  {
    return unsigned_flag;
  }

  virtual bool negative() const
  {
    return false;
  }

  bool with_sum_func;
  bool is_autogenerated_name; 
  bool with_subselect;
  DTCollation collation;
  Item_result cmp_context; 
  Item();

  Item(Session *session, Item *item);

  virtual ~Item()
  {
  }

  void set_name(str_ref arg)
  {
    set_name(arg.data(), arg.size());
  }

  void set_name(const char* arg)
  {
    set_name(str_ref(arg));
  }

  void set_name(const char *str, uint32_t length, const charset_info_st* cs= system_charset_info);
  void init_make_field(SendField *tmp_field, enum_field_types type);
  virtual void cleanup();
  virtual void make_field(SendField *field);
  Field *make_string_field(Table *table);
  virtual bool fix_fields(Session *, Item **);

  virtual void fix_after_pullout(Select_Lex *new_parent, Item **ref);

  inline void quick_fix_field()
  {
    fixed= true;
  }

  virtual int save_in_field(Field *field, bool no_conversions);
  virtual void save_org_in_field(Field *field)
  {
    (void) save_in_field(field, true);
  }
  virtual int save_safe_in_field(Field *field)
  {
    return save_in_field(field, true);
  }
  virtual void send(plugin::Client *client, String *str);
  virtual bool eq(const Item *, bool binary_cmp) const;
  virtual Item_result result_type() const
  {
    return REAL_RESULT;
  }
  virtual Item_result cast_to_int_type() const
  {
    return result_type();
  }
  virtual enum_field_types string_field_type() const;
  virtual enum_field_types field_type() const;
  virtual enum Type type() const =0;

  virtual int64_t val_int_endpoint(bool left_endp, bool *incl_endp);

  /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
  virtual double val_real()=0;
  virtual int64_t val_int()=0;
  inline uint64_t val_uint()
  {
    return (uint64_t) val_int();
  }
  virtual String *val_str(String *str)=0;

  virtual type::Decimal *val_decimal(type::Decimal *decimal_buffer)= 0;

  virtual bool val_bool();

  /* Helper functions, see item_sum.cc */
  String *val_string_from_real(String *str);
  String *val_string_from_int(String *str);
  String *val_string_from_decimal(String *str);
  type::Decimal *val_decimal_from_real(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_int(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_string(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_date(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_time(type::Decimal *decimal_value);
  int64_t val_int_from_decimal();
  double val_real_from_decimal();

  bool save_time_in_field(Field *field);
  bool save_date_in_field(Field *field);

  int save_str_value_in_field(Field *field, String *result);

  virtual Field *get_tmp_table_field(void)
  {
    return NULL;
  }
  /* This is also used to create fields in CREATE ... SELECT: */
  virtual Field *tmp_table_field(Table *t_arg);
  virtual const char *full_name(void) const;

  /*
    *result* family of methods is analog of *val* family (see above) but
    return value of result_field of item if it is present. If Item have not
    result field, it return val(). This methods set null_value flag in same
    way as *val* methods do it.
  */
  virtual double  val_result() 
  {
    return val_real();
  }
  virtual int64_t val_int_result()
  {
    return val_int();
  }
  virtual String *str_result(String* tmp)
  {
    return val_str(tmp);
  }
  virtual type::Decimal *val_decimal_result(type::Decimal *val)
  {
    return val_decimal(val);
  }
  virtual bool val_bool_result()
  {
    return val_bool();
  }
  virtual table_map used_tables() const
  {
    return (table_map) 0L;
  }
  virtual table_map not_null_tables() const
  {
    return used_tables();
  }
  virtual bool basic_const_item() const
  {
    return false;
  }
  /* cloning of constant items (NULL if it is not const) */
  virtual Item *clone_item()
  {
    return NULL;
  }
  virtual cond_result eq_cmp_result() const
  {
    return COND_OK;
  }
  uint32_t float_length(uint32_t decimals_par) const;
  virtual uint32_t decimal_precision() const;
  int decimal_int_part() const;

  virtual bool const_item() const
  {
    return used_tables() == 0;
  }
  virtual bool const_during_execution() const
  {
    return (used_tables() & ~PARAM_TABLE_BIT) == 0;
  }

  virtual void print(String *str);

  void print_item_w_name(String *);
  virtual void update_used_tables() {}
  virtual void split_sum_func(Session *session, 
                              Item **ref_pointer_array,
                              List<Item> &fields);
  void split_sum_func(Session *session, 
                      Item **ref_pointer_array,
                      List<Item> &fields,
                      Item **ref, 
                      bool skip_registered);

  virtual bool get_date(type::Time &ltime, uint32_t fuzzydate);
  virtual bool get_time(type::Time &ltime);
  virtual bool get_date_result(type::Time &ltime,uint32_t fuzzydate);

  virtual bool is_null();

  virtual void update_null_value ();

  virtual void top_level_item(void);
  virtual void set_result_field(Field *field);
  virtual bool is_result_field(void);
  virtual bool is_bool_func(void);
  virtual void save_in_result_field(bool no_conversions);

  virtual void no_rows_in_result(void);
  virtual Item *copy_or_same(Session *session);

  virtual Item *copy_andor_structure(Session *session);

  virtual Item *real_item(void);
  virtual const Item *real_item(void) const;
  virtual Item *get_tmp_table_item(Session *session);

  static const charset_info_st *default_charset();
  virtual const charset_info_st *compare_collation();

  virtual bool walk(Item_processor processor,
                    bool walk_subquery,
                    unsigned char *arg);

  virtual Item* transform(Item_transformer transformer, unsigned char *arg);

  virtual Item* compile(Item_analyzer analyzer, 
                        unsigned char **arg_p,
                        Item_transformer transformer, 
                        unsigned char *arg_t);

  virtual void traverse_cond(Cond_traverser traverser,
                             void *arg,
                             traverse_order order);

  virtual bool remove_dependence_processor(unsigned char * arg);
  virtual bool collect_item_field_processor(unsigned char * arg);
  virtual bool find_item_in_field_list_processor(unsigned char *arg);
  virtual bool change_context_processor(unsigned char *context);
  virtual bool register_field_in_read_map(unsigned char *arg);
  virtual bool subst_argument_checker(unsigned char **arg);

  virtual bool cache_const_expr_analyzer(unsigned char **arg);
  virtual Item* cache_const_expr_transformer(unsigned char *arg);

  virtual Item *equal_fields_propagator(unsigned char * arg);
  virtual bool set_no_const_sub(unsigned char *arg);
  virtual Item *replace_equal_field(unsigned char * arg);

  // Row emulation
  virtual uint32_t cols();
  virtual Item* element_index(uint32_t i);
  virtual Item** addr(uint32_t i);
  virtual bool check_cols(uint32_t c);
  // It is not row => null inside is impossible
  virtual bool null_inside();
  // used in row subselects to get value of elements
  virtual void bring_value();

  Field *tmp_table_field_from_field_type(Table *table, bool fixed_length);

  virtual Item *neg_transformer(Session *session);
  virtual Item *update_value_transformer(unsigned char *select_arg);
  virtual Item *safe_charset_converter(const charset_info_st * const tocs);
  void delete_self();

  virtual bool result_as_int64_t();
  bool is_datetime();

  virtual bool is_expensive();

  String *check_well_formed_result(String *str, bool send_error= 0);
  bool eq_by_collation(Item *item, bool binary_cmp, const charset_info_st * const cs);

  inline uint32_t char_to_byte_length_safe(uint32_t char_length_arg, uint32_t mbmaxlen_arg)
  { 
    uint64_t tmp= ((uint64_t) char_length_arg) * mbmaxlen_arg;
    return (tmp > UINT32_MAX) ? (uint32_t) UINT32_MAX : (uint32_t) tmp;
  } 

  uint32_t max_char_length() const;

  void fix_char_length(uint32_t max_char_length_arg);

protected:
  Session &getSession()
  {
    return _session;
  }

private:
  Session &_session;
};

namespace display {
const std::string &type(Item::Type type);
} /* namespace display */

std::ostream& operator<<(std::ostream& output, const Item &item);

} /* namespace drizzled */

#include <drizzled/item/ident.h>

namespace drizzled
{

void mark_as_dependent(Session *session,
           Select_Lex *last,
                       Select_Lex *current,
                       Item_ident *resolved_item,
                       Item_ident *mark_item);

Item** resolve_ref_in_select_and_group(Session *session, Item_ident *ref, Select_Lex *select);

void mark_select_range_as_dependent(Session *session,
                                    Select_Lex *last_select,
                                    Select_Lex *current_sel,
                                    Field *found_field, Item *found_item,
                                    Item_ident *resolved_item);

extern void resolve_const_item(Session *session, Item **ref, Item *cmp_item);
extern bool field_is_equal_to_item(Field *field,Item *item);

Field *create_tmp_field(Session *session,
                        Table *table,
                        Item *item,
                        Item::Type type,
                        Item ***copy_func,
                        Field **from_field,
                        Field **def_field,
                        bool group,
                        bool modify_item,
                        bool make_copy_field,
                        uint32_t convert_blob_length);

} /* namespace drizzled */