~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  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

 */

  uint64_t (*get_value_func)(THD *thd, Item ***item_arg, Item **cache_arg,

                                                      uint64_t *const_val_arg);

  uint32_t decimal_precision() const { return 1; }

  virtual int64_t val_int();

#define UNKNOWN ((bool)-1)

  bool result_for_null_param;

    Item_bool_func(a, reinterpret_cast<Item *>(b)), cache(0),

  { with_subselect= true; }

  int64_t val_int();

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

    :Item_int_func(a,b), cmp(tmp_arg, tmp_arg+1), abort_on_null(false) {}

  const CHARSET_INFO *compare_collation() { return cmp.cmp_collation.collation; }

  uint32_t decimal_precision() const { return 1; }

  void top_level_item() { abort_on_null= true; }

  bool subst_argument_checker(unsigned char **arg __attribute__((unused)))

  { return true; }

  int64_t val_int();

  int64_t val_int() { return *trig_var ? args[0]->val_int() : 1; }

  bool const_item() const { return false; }

  int64_t val_int();

  int64_t val_int();

  int64_t val_int();

  int64_t val_int();

  Item *neg_transformer(THD *thd __attribute__((unused))) { return 0; }

  int64_t val_int();

  int64_t val_int();

  int64_t val_int();

  int64_t val_int();

  int64_t val_int();

  Item *neg_transformer(THD *thd __attribute__((unused)))

  bool subst_argument_checker(unsigned char **arg __attribute__((unused)))

  { return true; }

    :Item_func_opt_neg(a, b, c), compare_as_dates(false) {}

  int64_t val_int();

  const CHARSET_INFO *compare_collation() { return cmp_collation.collation; }

  uint32_t decimal_precision() const { return 1; }

  int64_t val_int();

  bool use_decimal_comparison;

  int64_t val_int();

  uint32_t decimal_precision() const { return 2; }

  int64_t int_op();

  int64_t int_op();

  Field *tmp_table_field(Table *table);

  uint32_t decimal_precision() const;

  int64_t val_int();

  uint32_t decimal_precision() const;

  int64_t val_int();

  uint32_t decimal_precision() const { return args[0]->decimal_precision(); }

  uint32_t size;

  const CHARSET_INFO *collation;

  uint32_t count;

  uint32_t used_count;

  in_vector(uint32_t elements,uint32_t element_length,qsort2_cmp cmp_func, 

            const CHARSET_INFO * const cmp_coll)

  virtual void set(uint32_t pos,Item *item)=0;

  virtual unsigned char *get_value(Item *item)=0;

    my_qsort2(base,used_count,size,compare, (void *) collation);

  virtual void value_to_item(uint32_t pos __attribute__((unused)),

                             Item *item __attribute__((unused))) { }

  bool compare_elems(uint32_t pos1, uint32_t pos2)

  in_string(uint32_t elements,qsort2_cmp cmp_func, const CHARSET_INFO * const cs);

  void set(uint32_t pos,Item *item);

  unsigned char *get_value(Item *item);

  void value_to_item(uint32_t pos, Item *item)

class in_int64_t :public in_vector

  struct packed_int64_t 

    int64_t val;

    int64_t unsigned_flag;  // Use int64_t, not bool, to preserve alignment

  in_int64_t(uint32_t elements);

  void set(uint32_t pos,Item *item);

  unsigned char *get_value(Item *item);

    return new Item_int((int64_t)0);

  void value_to_item(uint32_t pos, Item *item)

    ((Item_int*) item)->value= ((packed_int64_t*) base)[pos].val;

    ((Item_int*) item)->unsigned_flag= (bool)

      ((packed_int64_t*) base)[pos].unsigned_flag;

  friend int cmp_int64_t(void *cmp_arg, packed_int64_t *a,packed_int64_t *b);

class in_datetime :public in_int64_t

  in_datetime(Item *warn_item_arg, uint32_t elements)

    :in_int64_t(elements), thd(current_thd), warn_item(warn_item_arg),

  void set(uint32_t pos,Item *item);

  unsigned char *get_value(Item *item);

  friend int cmp_int64_t(void *cmp_arg, packed_int64_t *a,packed_int64_t *b);

  in_double(uint32_t elements);

  void set(uint32_t pos,Item *item);

  unsigned char *get_value(Item *item);

  void value_to_item(uint32_t pos, Item *item)

  in_decimal(uint32_t elements);

  void set(uint32_t pos, Item *item);

  unsigned char *get_value(Item *item);

    return new Item_decimal(0, false);

  void value_to_item(uint32_t pos, Item *item)

  const CHARSET_INFO *cmp_charset;

  static cmp_item* get_comparator(Item_result type, const CHARSET_INFO * const cs);

  virtual void store_value_by_template(cmp_item *tmpl  __attribute__((unused)),

                                       Item *item)

  cmp_item_string (const CHARSET_INFO * const cs) { cmp_charset= cs; }

  void set_charset(const CHARSET_INFO * const cs) { cmp_charset= cs; }

  cmp_item_sort_string(const CHARSET_INFO * const cs):

  void set_charset(const CHARSET_INFO * const cs)

  int64_t value;

  uint64_t value;

  cmp_item_sort_string_in_static(const CHARSET_INFO * const cs):

  int cmp(Item *item __attribute__((unused)))