drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
table_function.cc
1/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 *
4 * Copyright (C) 2010 Monty Taylor
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 <config.h>
21
22#include <drizzled/current_session.h>
23#include <drizzled/gettext.h>
24#include <drizzled/charset.h>
25#include <drizzled/plugin/table_function.h>
26#include <drizzled/session.h>
27#include <drizzled/show.h>
28#include <drizzled/table_function_container.h>
29#include <drizzled/sql_lex.h>
30#include <drizzled/internal/my_sys.h>
31
32#include <vector>
33
34namespace drizzled {
35
36static int wild_case_compare(const charset_info_st * const cs, const char *str, const char *wildstr)
37{
38 int flag;
39
40 while (*wildstr)
41 {
42 while (*wildstr && *wildstr != internal::wild_many && *wildstr != internal::wild_one)
43 {
44 if (*wildstr == internal::wild_prefix && wildstr[1])
45 {
46 wildstr++;
47 }
48
49 if (cs->toupper(*wildstr++) != cs->toupper(*str++))
50 {
51 return (1);
52 }
53 }
54
55 if (! *wildstr )
56 return (*str != 0);
57
58 if (*wildstr++ == internal::wild_one)
59 {
60 if (! *str++)
61 {
62 return (1); /* One char; skip */
63 }
64 }
65 else
66 { /* Found '*' */
67 if (! *wildstr)
68 {
69 return (0); /* '*' as last char: OK */
70 }
71
72 flag=(*wildstr != internal::wild_many && *wildstr != internal::wild_one);
73 do
74 {
75 if (flag)
76 {
77 char cmp;
78 if ((cmp= *wildstr) == internal::wild_prefix && wildstr[1])
79 {
80 cmp= wildstr[1];
81 }
82
83 cmp= cs->toupper(cmp);
84
85 while (*str && cs->toupper(*str) != cmp)
86 {
87 str++;
88 }
89
90 if (! *str)
91 {
92 return (1);
93 }
94 }
95
96 if (wild_case_compare(cs, str, wildstr) == 0)
97 {
98 return (0);
99 }
100
101 } while (*str++);
102
103 return (1);
104 }
105 }
106
107 return (*str != '\0');
108}
109
110static TableFunctionContainer table_functions;
111
112void plugin::TableFunction::init()
113{
114 drizzled::message::table::init(proto, getTableLabel(), identifier.getSchemaName(), "FunctionEngine");
115 proto.set_type(drizzled::message::Table::FUNCTION);
116 proto.set_creation_timestamp(0);
117 proto.set_update_timestamp(0);
118 message::set_is_replicated(proto, false);
119 message::set_definer(proto, SYSTEM_USER);
120}
121
122bool plugin::TableFunction::addPlugin(plugin::TableFunction &tool)
123{
124 table_functions.addFunction(&tool);
125 return false;
126}
127
128plugin::TableFunction *plugin::TableFunction::getFunction(const std::string &arg)
129{
130 return table_functions.getFunction(arg);
131}
132
133void plugin::TableFunction::getNames(const std::string &arg,
134 std::set<std::string> &set_of_names)
135{
136 table_functions.getNames(arg, set_of_names);
137}
138
139LEX& plugin::TableFunction::Generator::lex()
140{
141 return getSession().lex();
142}
143
144statement::Statement& plugin::TableFunction::Generator::statement()
145{
146 return *lex().statement;
147}
148
149plugin::TableFunction::Generator *plugin::TableFunction::generator(Field **arg)
150{
151 return new Generator(arg);
152}
153
154void plugin::TableFunction::add_field(const char *label,
155 uint32_t field_length)
156{
157 add_field(label, TableFunction::STRING, field_length);
158}
159
160void plugin::TableFunction::add_field(const char *label,
161 TableFunction::ColumnType type,
162 bool is_default_null)
163{
164 add_field(label, type, 5, is_default_null);
165}
166
167void plugin::TableFunction::add_field(const char *label,
168 TableFunction::ColumnType type,
169 uint32_t field_length,
170 bool is_default_null)
171{
172 drizzled::message::Table::Field *field;
173 drizzled::message::Table::Field::FieldOptions *field_options;
174 drizzled::message::Table::Field::FieldConstraints *field_constraints;
175
176 field= proto.add_field();
177 field->set_name(label);
178
179 field_options= field->mutable_options();
180 field_constraints= field->mutable_constraints();
181 field_options->set_default_null(is_default_null);
182 field_constraints->set_is_notnull(not is_default_null);
183
184 switch (type)
185 {
186 case TableFunction::STRING:
187 {
188 drizzled::message::Table::Field::StringFieldOptions *string_field_options;
189 if (field_length >= TABLE_FUNCTION_BLOB_SIZE)
190 {
191 field->set_type(drizzled::message::Table::Field::BLOB);
192 string_field_options= field->mutable_string_options();
193 string_field_options->set_collation_id(default_charset_info->number);
194 string_field_options->set_collation(default_charset_info->name);
195 }
196 else
197 {
198 field->set_type(drizzled::message::Table::Field::VARCHAR);
199 string_field_options= field->mutable_string_options();
200 string_field_options->set_length(field_length);
201 }
202 }
203 break;
204 case TableFunction::VARBINARY:
205 {
206 drizzled::message::Table::Field::StringFieldOptions *string_field_options;
207 field->set_type(drizzled::message::Table::Field::VARCHAR);
208
209 string_field_options= field->mutable_string_options();
210 string_field_options->set_length(field_length);
211 string_field_options->set_collation(my_charset_bin.csname);
212 string_field_options->set_collation_id(my_charset_bin.number);
213 }
214 break;
215 case TableFunction::NUMBER:
216 field->set_type(drizzled::message::Table::Field::BIGINT);
217 break;
218 case TableFunction::SIZE:
219 field->set_type(drizzled::message::Table::Field::BIGINT);
220 field_constraints->set_is_unsigned(true);
221 break;
222 case TableFunction::BOOLEAN: // Currently BOOLEAN always has a value
223 field->set_type(drizzled::message::Table::Field::BOOLEAN);
224 field_constraints->set_is_unsigned(true);
225 break;
226 }
227}
228
229plugin::TableFunction::Generator::Generator(Field **arg) :
230 columns(arg),
231 session(current_session)
232{
233 scs= system_charset_info;
234}
235
236bool plugin::TableFunction::Generator::sub_populate(uint32_t field_size)
237{
238 columns_iterator= columns;
239 bool ret= populate();
240#ifndef NDEBUG
241 if (ret)
242 {
243 assert(columns_iterator == columns + field_size);
244 }
245#else
246 (void)field_size;
247#endif
248 return ret;
249}
250
251void plugin::TableFunction::Generator::push(uint64_t arg)
252{
253 (*columns_iterator)->store(static_cast<int64_t>(arg), true);
254 (*columns_iterator)->set_notnull();
255 columns_iterator++;
256}
257
258void plugin::TableFunction::Generator::push(int64_t arg)
259{
260 (*columns_iterator)->store(arg, false);
261 (*columns_iterator)->set_notnull();
262 columns_iterator++;
263}
264
265void plugin::TableFunction::Generator::push(const char *arg, uint32_t length)
266{
267 assert(columns_iterator);
268 assert(*columns_iterator);
269 if (arg and length == 0)
270 {
271 length= strlen(arg);
272 }
273
274 if ((*columns_iterator)->char_length() < length)
275 {
276 length= (*columns_iterator)->char_length();
277 }
278
279 (*columns_iterator)->store(arg, length, scs);
280 (*columns_iterator)->set_notnull();
281 columns_iterator++;
282}
283
284void plugin::TableFunction::Generator::push()
285{
286 /* Only accept NULLs */
287 assert((*columns_iterator)->maybe_null());
288 (*columns_iterator)->set_null();
289 columns_iterator++;
290}
291
292void plugin::TableFunction::Generator::push(str_ref arg)
293{
294 push(arg.data(), arg.size());
295}
296
297void plugin::TableFunction::Generator::push(bool arg)
298{
299 if (arg)
300 {
301 (*columns_iterator)->store("YES", 3, scs);
302 }
303 else
304 {
305 (*columns_iterator)->store("NO", 2, scs);
306 }
307 columns_iterator++;
308}
309
310bool plugin::TableFunction::Generator::isWild(const std::string &predicate)
311{
312 return lex().wild ? wild_case_compare(system_charset_info, predicate.c_str(), lex().wild->ptr()) : false;
313}
314
315} /* namespace drizzled */
TODO: Rename this file - func.h is stupid.