~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

 */

#include "config.h"

#include <drizzled/function/find_in_set.h>

/* Search after a string in a string of strings separated by ',' */

/* Returns number of found type >= 1 or 0 if not found */

/* This optimizes searching in enums to bit testing! */

namespace drizzled

{

void Item_func_find_in_set::fix_length_and_dec()

{

  decimals=0;

  max_length=3;                                 // 1-999

  agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV, 1);

}

static const char separator=',';

int64_t Item_func_find_in_set::val_int()

{

  assert(fixed == 1);

  if (enum_value)

  {

    uint64_t tmp=(uint64_t) args[1]->val_int();

    if (!(null_value=args[1]->null_value || args[0]->null_value))

    {

      if (tmp & enum_bit)

	return enum_value;

    }

    return 0L;

  }

  String *find=args[0]->val_str(&value);

  String *buffer=args[1]->val_str(&value2);

  if (!find || !buffer)

  {

    null_value=1;

    return 0;

  }

  null_value=0;

  int diff;

  if ((diff=buffer->length() - find->length()) >= 0)

  {

    my_wc_t wc;

    const CHARSET_INFO * const cs= cmp_collation.collation;

    const char *str_begin= buffer->ptr();

    const char *str_end= buffer->ptr();

    const char *real_end= str_end+buffer->length();

    const unsigned char *find_str= (const unsigned char *) find->ptr();

    uint32_t find_str_len= find->length();

    int position= 0;

    while (1)

    {

      int symbol_len;

      if ((symbol_len= cs->cset->mb_wc(cs, &wc, (unsigned char*) str_end,

                                       (unsigned char*) real_end)) > 0)

      {

        const char *substr_end= str_end + symbol_len;

        bool is_last_item= (substr_end == real_end);

        bool is_separator= (wc == (my_wc_t) separator);

        if (is_separator || is_last_item)

        {

          position++;

          if (is_last_item && !is_separator)

            str_end= substr_end;

          if (!my_strnncoll(cs, (const unsigned char *) str_begin,

                            str_end - str_begin,

                            find_str, find_str_len))

            return (int64_t) position;

          else

            str_begin= substr_end;

        }

        str_end= substr_end;

      }

      else if (str_end - str_begin == 0 &&

               find_str_len == 0 &&

               wc == (my_wc_t) separator)

        return (int64_t) ++position;

      else

        return 0L;

    }

  }

  return 0;

}

} /* namespace drizzled */