← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/utility_functions/user.cc

  • Committer: Brian Aker
  • Date: 2010-10-21 20:21:18 UTC
  • mfrom: (1864.3.5 catalogs)
  • mto: This revision was merged to the branch mainline in revision 1867.
  • Revision ID: brian@tangent.org-20101021202118-ld4u8ug30h7dsaxm
Merge of all refactor for functions into single plugin, this includes a new
catalog() function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/utility_functions/user.cc
20
20
 
21
21
#include "config.h"
22
22
 
23
 
#include <drizzled/plugin/function.h>
24
23
#include <drizzled/session.h>
25
 
 
26
 
using namespace std;
27
 
using namespace drizzled;
28
 
 
29
 
#include <drizzled/function/str/strfunc.h>
30
 
 
31
 
class UserFunction :public Item_str_func
32
 
{
33
 
protected:
34
 
  bool init (const char *user, const char *host);
35
 
 
36
 
public:
37
 
  UserFunction()
38
 
  {
39
 
    str_value.set("", 0, system_charset_info);
40
 
  }
41
 
  String *val_str(String *)
42
 
  {
43
 
    assert(fixed == 1);
44
 
    return (null_value ? 0 : &str_value);
45
 
  }
46
 
  bool fix_fields(Session *session, Item **ref);
47
 
  void fix_length_and_dec()
48
 
  {
49
 
    max_length= (USERNAME_CHAR_LENGTH + HOSTNAME_LENGTH + 1) *
50
 
                system_charset_info->mbmaxlen;
51
 
  }
52
 
  const char *func_name() const { return "user"; }
53
 
  const char *fully_qualified_func_name() const { return "user()"; }
54
 
  int save_in_field(Field *field,
55
 
                    bool )
56
 
  {
57
 
    return save_str_value_in_field(field, &str_value);
58
 
  }
59
 
};
60
 
 
61
 
/**
62
 
  @todo
63
 
  make USER() replicate properly (currently it is replicated to "")
64
 
*/
65
 
bool UserFunction::init(const char *user, const char *host)
 
24
#include "plugin/utility_functions/functions.h"
 
25
 
 
26
namespace drizzled
 
27
{
 
28
 
 
29
namespace utility_functions
 
30
{
 
31
 
 
32
 
 
33
String *User::val_str(String *str)
66
34
{
67
35
  assert(fixed == 1);
68
 
 
69
 
  // For system threads (e.g. replication SQL thread) user may be empty
70
 
  if (user)
71
 
  {
72
 
    const CHARSET_INFO * const cs= str_value.charset();
73
 
    uint32_t res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
74
 
 
75
 
    if (str_value.alloc(res_length))
76
 
    {
77
 
      null_value=1;
78
 
      return true;
79
 
    }
80
 
 
81
 
    res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), res_length,
82
 
                                  "%s@%s", user, host);
83
 
    str_value.length(res_length);
84
 
    str_value.mark_as_const();
85
 
  }
86
 
  return false;
87
 
}
88
 
 
89
 
 
90
 
bool UserFunction::fix_fields(Session *session, Item **ref)
91
 
{
92
 
  return (Item_str_func::fix_fields(session, ref) ||
93
 
          init(session->getSecurityContext().getUser().c_str(),
94
 
               session->getSecurityContext().getIp().c_str()));
95
 
}
96
 
 
97
 
 
98
 
plugin::Create_function<UserFunction> *user_function= NULL;
99
 
 
100
 
static int initialize(drizzled::module::Context &context)
101
 
{
102
 
  user_function= new plugin::Create_function<UserFunction>("user");
103
 
  context.add(user_function);
104
 
  return 0;
105
 
}
106
 
 
107
 
DRIZZLE_DECLARE_PLUGIN
108
 
{
109
 
  DRIZZLE_VERSION_ID,
110
 
  "user_function",
111
 
  "1.0",
112
 
  "Stewart Smith",
113
 
  "USER() and CURRENT_USER()",
114
 
  PLUGIN_LICENSE_GPL,
115
 
  initialize, /* Plugin Init */
116
 
  NULL,   /* system variables */
117
 
  NULL    /* config options */
118
 
}
119
 
DRIZZLE_DECLARE_PLUGIN_END;
 
36
  Session *session= current_session;
 
37
  if (session->getSecurityContext().getUser().empty())
 
38
  {
 
39
    null_value= 1;
 
40
    return 0;
 
41
  }
 
42
  else
 
43
  {
 
44
    str->copy(session->getSecurityContext().getUser().c_str(), session->getSecurityContext().getUser().length(), system_charset_info);
 
45
  }
 
46
  return str;
 
47
}
 
48
 
 
49
} /* namespace utility_functions */
 
50
} /* namespace drizzled */