~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 <drizzled/server_includes.h>

#include CSTDINT_H

#include <drizzled/functions/get_user_var.h>

#include <drizzled/functions/get_variable.h>

#include <drizzled/sql_parse.h>

#include <drizzled/session.h>

String *

Item_func_get_user_var::val_str(String *str)

{

  assert(fixed == 1);

  if (!var_entry)

    return((String*) 0);                        // No such variable

  return(var_entry->val_str(&null_value, str, decimals));

}

double Item_func_get_user_var::val_real()

{

  assert(fixed == 1);

  if (!var_entry)

    return 0.0;                                 // No such variable

  return (var_entry->val_real(&null_value));

}

my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec)

{

  assert(fixed == 1);

  if (!var_entry)

    return 0;

  return var_entry->val_decimal(&null_value, dec);

}

int64_t Item_func_get_user_var::val_int()

{

  assert(fixed == 1);

  if (!var_entry)

    return 0L;                          // No such variable

  return (var_entry->val_int(&null_value));

}

/**

  Get variable by name and, if necessary, put the record of variable

  use into the binary log.

  When a user variable is invoked from an update query (INSERT, UPDATE etc),

  stores this variable and its value in session->user_var_events, so that it can be

  written to the binlog (will be written just before the query is written, see

  log.cc).

  @param      session        Current thread

  @param      name       Variable name

  @param[out] out_entry  variable structure or NULL. The pointer is set

                         regardless of whether function succeeded or not.

  @retval

    0  OK

  @retval

    1  Failed to put appropriate record into binary log

*/

static int get_var_with_binlog(Session *session, enum_sql_command sql_command,

                               LEX_STRING &name, user_var_entry **out_entry)

{

  BINLOG_USER_VAR_EVENT *user_var_event;

  user_var_entry *var_entry;

  var_entry= get_variable(&session->user_vars, name, 0);

  /*

    Any reference to user-defined variable which is done from stored

    function or trigger affects their execution and the execution of the

    calling statement. We must log all such variables even if they are

    not involved in table-updating statements.

  */

  if (!(opt_bin_log && is_update_query(sql_command)))

  {

    *out_entry= var_entry;

    return 0;

  }

  if (!var_entry)

  {

    /*

      If the variable does not exist, it's NULL, but we want to create it so

      that it gets into the binlog (if it didn't, the slave could be

      influenced by a variable of the same name previously set by another

      thread).

      We create it like if it had been explicitly set with SET before.

      The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'.

      sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'

      in dispatch_command()). Instead of building a one-element list to pass to

      sql_set_variables(), we could instead manually call check() and update();

      this would save memory and time; but calling sql_set_variables() makes

      one unique place to maintain (sql_set_variables()).

      Manipulation with lex is necessary since free_underlaid_joins

      is going to release memory belonging to the main query.

    */

    List<set_var_base> tmp_var_list;

    LEX *sav_lex= session->lex, lex_tmp;

    session->lex= &lex_tmp;

    lex_start(session);

    tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(name,

                                                                       new Item_null())));

    /* Create the variable */

    if (sql_set_variables(session, &tmp_var_list))

    {

      session->lex= sav_lex;

      goto err;

    }

    session->lex= sav_lex;

    if (!(var_entry= get_variable(&session->user_vars, name, 0)))

      goto err;

  }

  else if (var_entry->used_query_id == session->query_id ||

           drizzle_bin_log.is_query_in_union(session, var_entry->used_query_id))

  {

    /*

       If this variable was already stored in user_var_events by this query

       (because it's used in more than one place in the query), don't store

       it.

    */

    *out_entry= var_entry;

    return 0;

  }

  uint32_t size;

  /*

    First we need to store value of var_entry, when the next situation

    appears:

    > set @a:=1;

    > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);

    We have to write to binlog value @a= 1.

    We allocate the user_var_event on user_var_events_alloc pool, not on

    the this-statement-execution pool because in SPs user_var_event objects

    may need to be valid after current [SP] statement execution pool is

    destroyed.

  */

  size= ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT)) + var_entry->length;

  if (!(user_var_event= (BINLOG_USER_VAR_EVENT *)

        alloc_root(session->user_var_events_alloc, size)))

    goto err;

  user_var_event->value= (char*) user_var_event +

    ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT));

  user_var_event->user_var_event= var_entry;

  user_var_event->type= var_entry->type;

  user_var_event->charset_number= var_entry->collation.collation->number;

  if (!var_entry->value)

  {

    /* NULL value*/

    user_var_event->length= 0;

    user_var_event->value= 0;

  }

  else

  {

    user_var_event->length= var_entry->length;

    memcpy(user_var_event->value, var_entry->value,

           var_entry->length);

  }

  /* Mark that this variable has been used by this query */

  var_entry->used_query_id= session->query_id;

  if (insert_dynamic(&session->user_var_events, (unsigned char*) &user_var_event))

    goto err;

  *out_entry= var_entry;

  return 0;

err:

  *out_entry= var_entry;

  return 1;

}

void Item_func_get_user_var::fix_length_and_dec()

{

  Session *session=current_session;

  int error;

  maybe_null=1;

  decimals=NOT_FIXED_DEC;

  max_length=MAX_BLOB_WIDTH;

  error= get_var_with_binlog(session, session->lex->sql_command, name, &var_entry);

  /*

    If the variable didn't exist it has been created as a STRING-type.

    'var_entry' is NULL only if there occured an error during the call to

    get_var_with_binlog.

  */

  if (var_entry)

  {

    m_cached_result_type= var_entry->type;

    unsigned_flag= var_entry->unsigned_flag;

    max_length= var_entry->length;

    collation.set(var_entry->collation);

    switch(m_cached_result_type) {

    case REAL_RESULT:

      max_length= DBL_DIG + 8;

      break;

    case INT_RESULT:

      max_length= MAX_BIGINT_WIDTH;

      decimals=0;

      break;

    case STRING_RESULT:

      max_length= MAX_BLOB_WIDTH;

      break;

    case DECIMAL_RESULT:

      max_length= DECIMAL_MAX_STR_LENGTH;

      decimals= DECIMAL_MAX_SCALE;

      break;

    case ROW_RESULT:                            // Keep compiler happy

    default:

      assert(0);

      break;

    }

  }

  else

  {

    collation.set(&my_charset_bin, DERIVATION_IMPLICIT);

    null_value= 1;

    m_cached_result_type= STRING_RESULT;

    max_length= MAX_BLOB_WIDTH;

  }

}

bool Item_func_get_user_var::const_item() const

{

  return (!var_entry || current_session->query_id != var_entry->update_query_id);

}

enum Item_result Item_func_get_user_var::result_type() const

{

  return m_cached_result_type;

}

void Item_func_get_user_var::print(String *str,

                                   enum_query_type query_type __attribute__((unused)))

{

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

  str->append(name.str,name.length);

  str->append(')');

}

bool Item_func_get_user_var::eq(const Item *item,

                                bool binary_cmp __attribute__((unused))) const

{

  /* Assume we don't have rtti */

  if (this == item)

    return 1;					// Same item is same.

  /* Check if other type is also a get_user_var() object */

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

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

    return 0;

  Item_func_get_user_var *other=(Item_func_get_user_var*) item;

  return (name.length == other->name.length &&

	  !memcmp(name.str, other->name.str, name.length));

}