← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/benchmark/benchmarkudf.cc

Merge Devananda's BENCHMARK UDF plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/benchmark/benchmarkudf.cc
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 * Copyright (C) 2008 MySQL AB
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
 
18
 */
 
19
 
 
20
#include <drizzled/server_includes.h>
 
21
#include <drizzled/error.h>
 
22
#include <drizzled/session.h>
 
23
 
 
24
using namespace std;
 
25
 
 
26
class BenchmarkFunction :public Item_int_func
 
27
{
 
28
public:
 
29
  BenchmarkFunction() :Item_int_func() {}
 
30
  int64_t val_int();
 
31
  virtual void print(String *str, enum_query_type query_type);
 
32
 
 
33
  const char *func_name() const
 
34
  { 
 
35
    return "benchmark"; 
 
36
  }
 
37
 
 
38
  void fix_length_and_dec()
 
39
  { 
 
40
    max_length= 1; 
 
41
    maybe_null= false;
 
42
  }
 
43
 
 
44
  bool check_argument_count(int n)
 
45
  { 
 
46
    return (n == 2); 
 
47
  }
 
48
};
 
49
 
 
50
 
 
51
/* This function is just used to test speed of different functions */
 
52
int64_t BenchmarkFunction::val_int()
 
53
{
 
54
  assert(fixed == true);
 
55
 
 
56
  char buff[MAX_FIELD_WIDTH];
 
57
  String tmp(buff,sizeof(buff), &my_charset_bin);
 
58
  my_decimal tmp_decimal;
 
59
  Session *session= current_session;
 
60
  uint64_t loop_count;
 
61
 
 
62
  loop_count= (uint64_t) args[0]->val_int();
 
63
 
 
64
  if (args[0]->null_value ||
 
65
      (args[0]->unsigned_flag == false && (((int64_t) loop_count) < 0)))
 
66
  {
 
67
    if (args[0]->null_value == false)
 
68
    {
 
69
      llstr(((int64_t) loop_count), buff);
 
70
      push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
71
                          ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
 
72
                          "count", buff, "benchmark");
 
73
    }
 
74
 
 
75
    null_value= true;
 
76
    return 0;
 
77
  }
 
78
 
 
79
  null_value= false;
 
80
 
 
81
  uint64_t loop;
 
82
  for (loop= 0 ; loop < loop_count && !session->killed; loop++)
 
83
  {
 
84
    switch (args[1]->result_type()) 
 
85
    {
 
86
    case REAL_RESULT:
 
87
      (void) args[1]->val_real();
 
88
      break;
 
89
    case INT_RESULT:
 
90
      (void) args[1]->val_int();
 
91
      break;
 
92
    case STRING_RESULT:
 
93
      (void) args[1]->val_str(&tmp);
 
94
      break;
 
95
    case DECIMAL_RESULT:
 
96
      (void) args[1]->val_decimal(&tmp_decimal);
 
97
      break;
 
98
    case ROW_RESULT:
 
99
    default:
 
100
      // This case should never be chosen
 
101
      assert(0);
 
102
      return 0;
 
103
    }
 
104
  }
 
105
  return 0;
 
106
}
 
107
 
 
108
void BenchmarkFunction::print(String *str, enum_query_type query_type)
 
109
{
 
110
  str->append(STRING_WITH_LEN("benchmark("));
 
111
  args[0]->print(str, query_type);
 
112
  str->append(',');
 
113
  args[1]->print(str, query_type);
 
114
  str->append(')');
 
115
}
 
116
 
 
117
Create_function<BenchmarkFunction> benchmarkudf(string("benchmark"));
 
118
 
 
119
static int initialize(PluginRegistry &registry)
 
120
{
 
121
  registry.add(&benchmarkudf);
 
122
  return 0;
 
123
}
 
124
 
 
125
static int finalize(PluginRegistry &registry)
 
126
{
 
127
   registry.remove(&benchmarkudf);
 
128
   return 0;
 
129
}
 
130
 
 
131
drizzle_declare_plugin(benchmark)
 
132
{
 
133
  "benchmark",
 
134
  "1.0",
 
135
  "Devananda van der Veen",
 
136
  "Measure time for repeated calls to a function.",
 
137
  PLUGIN_LICENSE_GPL,
 
138
  initialize, /* Plugin Init */
 
139
  finalize,   /* Plugin Deinit */
 
140
  NULL,   /* status variables */
 
141
  NULL,   /* system variables */
 
142
  NULL    /* config options */
 
143
}
 
144
drizzle_declare_plugin_end;