← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/set_var.cc

  • Committer: Marisa Plumb
  • Date: 2010-12-04 02:38:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1984.
  • Revision ID: marisa.plumb@gmail.com-20101204023829-2khzxh30wxi256db
updates to a few sql docs 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/set_var.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <config.h>
 
20
#include "config.h"
21
21
 
22
22
#include <boost/lexical_cast.hpp>
23
 
#include <boost/exception/get_error_info.hpp>
24
23
#include <string>
25
24
 
26
 
#include <drizzled/session.h>
27
 
#include <drizzled/item/string.h>
28
 
#include <drizzled/sql_list.h>
29
 
#include <drizzled/function/set_user_var.h>
 
25
#include "drizzled/session.h"
 
26
#include "drizzled/item/string.h"
 
27
#include "drizzled/sql_list.h"
30
28
 
31
29
using namespace std;
32
30
 
53
51
    -1  ERROR, message not sent
54
52
*/
55
53
 
56
 
int sql_set_variables(Session *session, const SetVarVector &var_list)
 
54
int sql_set_variables(Session *session, List<set_var_base> *var_list)
57
55
{
58
56
  int error;
59
 
 
60
 
  SetVarVector::const_iterator it(var_list.begin());
61
 
 
62
 
  while (it != var_list.end())
 
57
  List_iterator_fast<set_var_base> it(*var_list);
 
58
 
 
59
  set_var_base *var;
 
60
  while ((var=it++))
63
61
  {
64
 
    if ((error= (*it)->check(session)))
 
62
    if ((error= var->check(session)))
65
63
      goto err;
66
 
    ++it;
67
64
  }
68
65
  if (!(error= test(session->is_error())))
69
66
  {
70
 
    it= var_list.begin();
71
 
    while (it != var_list.end())
72
 
    {
73
 
      error|= (*it)->update(session);         // Returns 0, -1 or 1
74
 
      ++it;
75
 
    }
 
67
    it.rewind();
 
68
    while ((var= it++))
 
69
      error|= var->update(session);         // Returns 0, -1 or 1
76
70
  }
77
71
 
78
72
err:
79
 
  free_underlaid_joins(session, &session->getLex()->select_lex);
 
73
  free_underlaid_joins(session, &session->lex->select_lex);
80
74
  return(error);
81
75
}
82
76
 
86
80
*****************************************************************************/
87
81
set_var::set_var(sql_var_t type_arg, sys_var *var_arg,
88
82
                 const LEX_STRING *base_name_arg, Item *value_arg) :
89
 
  uint64_t_value(0),
90
 
  str_value(""),
91
 
  var(var_arg),
92
 
  type(type_arg),
93
 
  base(*base_name_arg)
 
83
  var(var_arg), type(type_arg), base(*base_name_arg)
94
84
{
95
85
  /*
96
86
    If the set value is a field, change it to a string to allow things like
105
95
      value=value_arg;                  /* Give error message later */
106
96
  }
107
97
  else
108
 
  {
109
 
    value= value_arg;
110
 
  }
 
98
    value=value_arg;
111
99
}
112
100
 
113
101
int set_var::check(Session *session)
120
108
  if (var->check_type(type))
121
109
  {
122
110
    int err= type == OPT_GLOBAL ? ER_LOCAL_VARIABLE : ER_GLOBAL_VARIABLE;
123
 
    my_error(static_cast<drizzled::error_t>(err), MYF(0), var->getName().c_str());
 
111
    my_error(err, MYF(0), var->getName().c_str());
124
112
    return -1;
125
113
  }
126
114
  /* value is a NULL pointer if we are using SET ... = DEFAULT */
168
156
    if (var->getAfterUpdateTrigger())
169
157
      (*var->getAfterUpdateTrigger())(session, type);
170
158
  }
171
 
  catch (invalid_option_value &ex)
 
159
  catch (boost::exception &)
172
160
  {
173
161
    /* TODO: Fix this to be typesafe once we have properly typed set_var */
174
 
    string new_val= boost::lexical_cast<string>(uint64_t_value);
175
 
    if (boost::get_error_info<invalid_max_info>(ex) != NULL)
176
 
    { 
177
 
      const uint64_t max_val= *(boost::get_error_info<invalid_max_info>(ex));
178
 
      string explanation("(> ");
179
 
      explanation.append(boost::lexical_cast<std::string>(max_val));
180
 
      explanation.push_back(')');
181
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
182
 
                          ER_INVALID_OPTION_VALUE,
183
 
                          ER(ER_INVALID_OPTION_VALUE),
184
 
                          var->getName().c_str(),
185
 
                          new_val.c_str(),
186
 
                          explanation.c_str());
187
 
    }
188
 
    else if (boost::get_error_info<invalid_min_info>(ex) != NULL)
189
 
    { 
190
 
      const int64_t min_val= *(boost::get_error_info<invalid_min_info>(ex));
191
 
      string explanation("(< ");
192
 
      explanation.append(boost::lexical_cast<std::string>(min_val));
193
 
      explanation.push_back(')');
194
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
195
 
                          ER_INVALID_OPTION_VALUE,
196
 
                          ER(ER_INVALID_OPTION_VALUE),
197
 
                          var->getName().c_str(),
198
 
                          new_val.c_str(),
199
 
                          explanation.c_str());
200
 
    }
201
 
    else if (boost::get_error_info<invalid_value>(ex) != NULL)
202
 
    {
203
 
      const std::string str_val= *(boost::get_error_info<invalid_value>(ex));
204
 
      string explanation("(");
205
 
      explanation.append(str_val);
206
 
      explanation.push_back(')');
207
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
208
 
                          ER_INVALID_OPTION_VALUE,
209
 
                          ER(ER_INVALID_OPTION_VALUE),
210
 
                          var->getName().c_str(),
211
 
                          new_val.c_str(),
212
 
                          explanation.c_str());
213
 
    }
214
 
    else
215
 
    {
216
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
217
 
                          ER_INVALID_OPTION_VALUE,
218
 
                          ER(ER_INVALID_OPTION_VALUE),
219
 
                          var->getName().c_str(),
220
 
                          new_val.c_str(),
221
 
                          "");
222
 
    }
 
162
    string new_val= boost::lexical_cast<string>(save_result.uint32_t_value);
 
163
    push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
164
                        ER_TRUNCATED_WRONG_VALUE,
 
165
                        ER(ER_TRUNCATED_WRONG_VALUE), var->getName().c_str(),
 
166
                        new_val.c_str());
223
167
  }
224
168
  return 0;
225
169
}
250
194
  return 0;
251
195
}
252
196
 
253
 
void set_var::setValue(const std::string &new_value)
254
 
{
255
 
  str_value= new_value;
256
 
}
257
 
 
258
 
void set_var::setValue(uint64_t new_value)
259
 
{
260
 
  uint64_t_value= new_value;
261
 
}
262
 
 
263
 
void set_var::updateValue()
264
 
{
265
 
  if (var->show_type() != SHOW_CHAR)
266
 
  {
267
 
    uint64_t_value= value->val_int();
268
 
  }
269
 
}
270
 
 
271
 
 
272
197
} /* namespace drizzled */