~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, 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

 */

#include "config.h"

#include "drizzled/temporal.h"

#include "drizzled/error.h"

#include "drizzled/session.h"

#include "drizzled/calendar.h"

#include "drizzled/function/time/extract.h"

namespace drizzled

{

/*

   'interval_names' reflects the order of the enumeration interval_type.

   See item/time.h

 */

extern const char *interval_names[];

void Item_extract::print(String *str, enum_query_type query_type)

{

  str->append(STRING_WITH_LEN("extract("));

  str->append(interval_names[int_type]);

  str->append(STRING_WITH_LEN(" from "));

  args[0]->print(str, query_type);

  str->append(')');

}

void Item_extract::fix_length_and_dec()

{

  value.alloc(DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING);				

  maybe_null= 1;					/* If NULL supplied only */

  switch (int_type) {

  case INTERVAL_YEAR:		max_length=4; date_value=1; break;

  case INTERVAL_YEAR_MONTH:	max_length=6; date_value=1; break;

  case INTERVAL_QUARTER:        max_length=2; date_value=1; break;

  case INTERVAL_MONTH:		max_length=2; date_value=1; break;

  case INTERVAL_WEEK:		max_length=2; date_value=1; break;

  case INTERVAL_DAY:		max_length=2; date_value=1; break;

  case INTERVAL_DAY_HOUR:	max_length=9; date_value=0; break;

  case INTERVAL_DAY_MINUTE:	max_length=11; date_value=0; break;

  case INTERVAL_DAY_SECOND:	max_length=13; date_value=0; break;

  case INTERVAL_HOUR:		max_length=2; date_value=0; break;

  case INTERVAL_HOUR_MINUTE:	max_length=4; date_value=0; break;

  case INTERVAL_HOUR_SECOND:	max_length=6; date_value=0; break;

  case INTERVAL_MINUTE:		max_length=2; date_value=0; break;

  case INTERVAL_MINUTE_SECOND:	max_length=4; date_value=0; break;

  case INTERVAL_SECOND:		max_length=2; date_value=0; break;

  case INTERVAL_MICROSECOND:	max_length=2; date_value=0; break;

  case INTERVAL_DAY_MICROSECOND: max_length=20; date_value=0; break;

  case INTERVAL_HOUR_MICROSECOND: max_length=13; date_value=0; break;

  case INTERVAL_MINUTE_MICROSECOND: max_length=11; date_value=0; break;

  case INTERVAL_SECOND_MICROSECOND: max_length=9; date_value=0; break;

  case INTERVAL_LAST: assert(0); break;

  }

}

int64_t Item_extract::val_int()

{

  assert(fixed);

  if (args[0]->is_null())

  {

    /* For NULL argument, we return a NULL result */

    null_value= true;

    return 0;

  }

  /* We could have either a datetime or a time.. */

  DateTime datetime_temporal;

  Time time_temporal;

  /* Abstract pointer type we'll use in the final switch */

  Temporal *temporal;

  if (date_value)

  {

    /* Grab the first argument as a DateTime object */

    Item_result arg0_result_type= args[0]->result_type();

    switch (arg0_result_type)

    {

      case DECIMAL_RESULT: 

        /* 

        * For doubles supplied, interpret the arg as a string, 

        * so intentionally fall-through here...

        * This allows us to accept double parameters like 

        * 19971231235959.01 and interpret it the way MySQL does:

        * as a TIMESTAMP-like thing with a microsecond component.

        * Ugh, but need to keep backwards-compat.

        */

      case STRING_RESULT:

        {

          char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];

          String tmp(buff,sizeof(buff), &my_charset_utf8_bin);

          String *res= args[0]->val_str(&tmp);

          if (res && (res != &tmp))

          {

            tmp.copy(*res);

          }

          if (! datetime_temporal.from_string(tmp.c_ptr(), tmp.length()))

          {

            /* 

            * Could not interpret the function argument as a temporal value, 

            * so throw an error and return 0

            */

            my_error(ER_INVALID_DATETIME_VALUE, MYF(0), tmp.c_ptr());

            return 0;

          }

        }

        break;

      case INT_RESULT:

        if (datetime_temporal.from_int64_t(args[0]->val_int()))

          break;

        /* Intentionally fall-through on invalid conversion from integer */

      default:

        {

          /* 

          * Could not interpret the function argument as a temporal value, 

          * so throw an error and return 0

          */

          null_value= true;

          char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];

          String tmp(buff,sizeof(buff), &my_charset_utf8_bin);

          String *res;

          res= args[0]->val_str(&tmp);

          if (res && (res != &tmp))

          {

            tmp.copy(*res);

          }

          my_error(ER_INVALID_DATETIME_VALUE, MYF(0), tmp.c_ptr());

          return 0;

        }

    }

    /* 

     * If we got here, we have a successfully converted DateTime temporal. 

     * Point our working temporal to this.

     */

    temporal= &datetime_temporal;

  }

  else

  {

    /* 

     * Because of the ridiculous way in which MySQL handles

     * TIME values (it does implicit integer -> string conversions

     * but only for DATETIME, not TIME values) we must first 

     * try a conversion into a TIME from a string.  If this

     * fails, we fall back on a DATETIME conversion.  This is

     * necessary because of the fact that DateTime::from_string()

     * looks first for DATETIME, then DATE regex matches.  6 consecutive

     * numbers, say 231130, will match the DATE regex YYMMDD

     * with no TIME part, but MySQL actually implicitly treats

     * parameters to SECOND(), HOUR(), and MINUTE() as TIME-only

     * values and matches 231130 as HHmmSS!

     *

     * Oh, and Brian Aker MADE me do this. :) --JRP

     */

    char time_buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];

    String tmp_time(time_buff,sizeof(time_buff), &my_charset_utf8_bin);

    String *time_res= args[0]->val_str(&tmp_time);

    if (time_res && (time_res != &tmp_time))

    {

      tmp_time.copy(*time_res);

    }

    if (! time_temporal.from_string(tmp_time.c_ptr(), tmp_time.length()))

    {

      /* 

       * OK, we failed to match the first argument as a string

       * representing a time value, so we grab the first argument 

       * as a DateTime object and try that for a match...

       */

      Item_result arg0_result_type= args[0]->result_type();

      switch (arg0_result_type)

      {

        case DECIMAL_RESULT: 

          /* 

           * For doubles supplied, interpret the arg as a string, 

           * so intentionally fall-through here...

           * This allows us to accept double parameters like 

           * 19971231235959.01 and interpret it the way MySQL does:

           * as a TIMESTAMP-like thing with a microsecond component.

           * Ugh, but need to keep backwards-compat.

           */

        case STRING_RESULT:

          {

            char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];

            String tmp(buff,sizeof(buff), &my_charset_utf8_bin);

            String *res= args[0]->val_str(&tmp);

            if (res && (res != &tmp))

            {

              tmp.copy(*res);

            }

            if (! datetime_temporal.from_string(tmp.c_ptr(), tmp.length()))

            {

              /* 

               * Could not interpret the function argument as a temporal value, 

               * so throw an error and return 0

               */

              my_error(ER_INVALID_DATETIME_VALUE, MYF(0), tmp.c_ptr());

              return 0;

            }

          }

          break;

        case INT_RESULT:

          if (datetime_temporal.from_int64_t(args[0]->val_int()))

            break;

          /* Intentionally fall-through on invalid conversion from integer */

        default:

          {

            /* 

             * Could not interpret the function argument as a temporal value, 

             * so throw an error and return 0

             */

            null_value= true;

            char buff[DRIZZLE_MAX_LENGTH_DATETIME_AS_STRING];

            String tmp(buff,sizeof(buff), &my_charset_utf8_bin);

            String *res;

            res= args[0]->val_str(&tmp);

            my_error(ER_INVALID_DATETIME_VALUE, MYF(0), res->c_ptr());

            return 0;

          }

      }

      /* If we're here, our time failed, but our datetime succeeded... */

      temporal= &datetime_temporal;

    }

    else

    {

      /* If we're here, our time succeeded... */

      temporal= &time_temporal;

    }

  }

  /* Return the requested datetime component */

  switch (int_type) {

    case INTERVAL_YEAR:		

      return (int64_t) temporal->years();

    case INTERVAL_YEAR_MONTH:	

      return (int64_t) ((temporal->years() * 100L) + temporal->months());

    case INTERVAL_QUARTER:

      return (int64_t) (temporal->months() + 2) / 3;

    case INTERVAL_MONTH:

      return (int64_t) temporal->months();

    case INTERVAL_WEEK:

      return iso_week_number_from_gregorian_date(temporal->years()

                                               , temporal->months()

                                               , temporal->days());

    case INTERVAL_DAY:

      return (int64_t) temporal->days();

    case INTERVAL_DAY_HOUR:	

      return (int64_t) ((temporal->days() * 100L) + temporal->hours());

    case INTERVAL_DAY_MINUTE:	

      return (int64_t) ((temporal->days() * 10000L)

            + (temporal->hours() * 100L) 

            + temporal->minutes());

    case INTERVAL_DAY_SECOND:	 

      return (int64_t) (

              (int64_t) (temporal->days() * 1000000L) 

            + (int64_t) (temporal->hours() * 10000L)

            + (temporal->minutes() * 100L) 

            + temporal->seconds());

    case INTERVAL_HOUR:		

      return (int64_t) temporal->hours();

    case INTERVAL_HOUR_MINUTE:	

      return (int64_t) (temporal->hours() * 100L) 

            + temporal->minutes();

    case INTERVAL_HOUR_SECOND:	

      return (int64_t) (temporal->hours() * 10000L) 

            + (temporal->minutes() * 100L) 

            + temporal->seconds();

    case INTERVAL_MINUTE:

      return (int64_t) temporal->minutes();

    case INTERVAL_MINUTE_SECOND:	

      return (int64_t) (temporal->minutes() * 100L) + temporal->seconds();

    case INTERVAL_SECOND:

      return (int64_t) temporal->seconds();

    case INTERVAL_MICROSECOND:	

      return (int64_t) temporal->useconds();

    case INTERVAL_DAY_MICROSECOND: 

      return (int64_t) 

              (

              (

              (int64_t) (temporal->days() * 1000000L) 

            + (int64_t) (temporal->hours() * 10000L) 

            + (temporal->minutes() * 100L) 

            + temporal->seconds()

              ) 

              * 1000000L

              ) 

            + temporal->useconds();

    case INTERVAL_HOUR_MICROSECOND:

        return (int64_t)

              (

              (

              (int64_t) (temporal->hours() * 10000L) 

            + (temporal->minutes() * 100L) 

            + temporal->seconds()

              ) 

              * 1000000L

              ) 

            + temporal->useconds();

    case INTERVAL_MINUTE_MICROSECOND:

        return (int64_t)

              (

              (

              (temporal->minutes() * 100L) 

            + temporal->seconds()

              ) 

              * 1000000L

              ) 

            + temporal->useconds();

    case INTERVAL_SECOND_MICROSECOND: 

        return (int64_t) (temporal->seconds() * 1000000L)

            + temporal->useconds();

    case INTERVAL_LAST: 

    default:

        assert(0); 

        return 0;

  }

}

bool Item_extract::eq(const Item *item, bool binary_cmp) const

{

  if (this == item)

    return 1;

  if (item->type() != FUNC_ITEM ||

      functype() != ((Item_func*)item)->functype())

    return 0;

  Item_extract* ie= (Item_extract*)item;

  if (ie->int_type != int_type)

    return 0;

  if (!args[0]->eq(ie->args[0], binary_cmp))

      return 0;

  return 1;

}

} /* namespace drizzled */