drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
singular.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 Brian Aker
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; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21#include <config.h>
22
23#include <sys/types.h>
24#include <sys/stat.h>
25#include <fcntl.h>
26
27#include <drizzled/session.h>
28#include <plugin/myisam/myisam.h>
29#include <drizzled/plugin/transactional_storage_engine.h>
30#include <drizzled/statistics_variables.h>
31#include <drizzled/table.h>
32#include <drizzled/create_field.h>
33#include <drizzled/key_part_info.h>
34
35namespace drizzled {
36namespace table {
37
38Singular::Singular(Session *session, std::list<CreateField>& field_list) :
39 _share(message::Table::INTERNAL),
40 _has_variable_width(false)
41{
42 uint32_t field_count= field_list.size();
43 uint32_t blob_count= 0;
44 uint32_t record_length= 0;
45 uint32_t null_count= 0; /* number of columns which may be null */
46 uint32_t null_pack_length; /* NULL representation array length */
47
48 getMutableShare()->setFields(field_count + 1);
49 setFields(getMutableShare()->getFields(true));
50 Field** field_arg= getMutableShare()->getFields(true);
51 getMutableShare()->blob_field.resize(field_count+1);
52 getMutableShare()->setFieldSize(field_count);
53 getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
54 setup_tmp_table_column_bitmaps();
55
56 in_use= session; /* field_arg->reset() may access in_use */
57
58 /* Create all fields and calculate the total length of record */
59 message::Table::Field null_field;
60 for (CreateField& it : field_list)
61 {
62 *field_arg= getMutableShare()->make_field(null_field,
63 NULL,
64 it.length,
65 (it.flags & NOT_NULL_FLAG) ? false : true,
66 (unsigned char *) ((it.flags & NOT_NULL_FLAG) ? 0 : ""),
67 (it.flags & NOT_NULL_FLAG) ? 0 : 1,
68 it.decimals,
69 it.sql_type,
70 it.charset,
71 it.unireg_check,
72 it.interval,
73 it.field_name,
74 it.flags & UNSIGNED_FLAG ? true : false);
75 (*field_arg)->init(this);
76 record_length+= (*field_arg)->pack_length();
77 if (! ((*field_arg)->flags & NOT_NULL_FLAG))
78 null_count++;
79
80 if ((*field_arg)->flags & BLOB_FLAG)
81 getMutableShare()->blob_field[blob_count++]= (uint32_t) (field_arg - getFields());
82
83 field_arg++;
84 }
85 *field_arg= NULL; /* mark the end of the list */
86 getMutableShare()->blob_field[blob_count]= 0; /* mark the end of the list */
87 getMutableShare()->blob_fields= blob_count;
88
89 null_pack_length= (null_count + 7)/8;
90 getMutableShare()->setRecordLength(record_length + null_pack_length);
91 getMutableShare()->rec_buff_length= ALIGN_SIZE(getMutableShare()->getRecordLength() + 1);
92 record[0]= session->mem.alloc(getMutableShare()->rec_buff_length);
93
94 if (null_pack_length)
95 {
96 null_flags= getInsertRecord();
97 getMutableShare()->null_fields= null_count;
98 getMutableShare()->null_bytes= null_pack_length;
99 }
100 {
101 /* Set up field pointers */
102 unsigned char *null_pos= getInsertRecord();
103 unsigned char *field_pos= null_pos + getMutableShare()->null_bytes;
104 uint32_t null_bit= 1;
105
106 for (field_arg= getFields(); *field_arg; ++field_arg)
107 {
108 Field *cur_field= *field_arg;
109 if ((cur_field->flags & NOT_NULL_FLAG))
110 cur_field->move_field(field_pos);
111 else
112 {
113 cur_field->move_field(field_pos, (unsigned char*) null_pos, null_bit);
114 null_bit<<= 1;
115 if (null_bit == (1 << 8))
116 {
117 ++null_pos;
118 null_bit= 1;
119 }
120 }
121 cur_field->reset();
122
123 field_pos+= cur_field->pack_length();
124 }
125 }
126}
127
128bool Singular::open_tmp_table()
129{
130 if (int error= cursor->ha_open(getShare()->getTableIdentifier(), O_RDWR, HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE))
131 {
132 print_error(error, MYF(0));
133 db_stat= 0;
134 return true;
135 }
136 (void) cursor->extra(HA_EXTRA_QUICK); /* Faster */
137 return false;
138}
139
140
141/*
142 Create MyISAM temporary table
143
144 SYNOPSIS
145 create_myisam_tmp_table()
146 keyinfo Description of the index (there is always one index)
147 start_recinfo MyISAM's column descriptions
148 recinfo INOUT End of MyISAM's column descriptions
149 options Option bits
150
151 DESCRIPTION
152 Create a MyISAM temporary table according to passed description. The is
153 assumed to have one unique index or constraint.
154
155 The passed array or MI_COLUMNDEF structures must have this form:
156
157 1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte
158 when there are many nullable columns)
159 2. Table columns
160 3. One free MI_COLUMNDEF element (*recinfo points here)
161
162 This function may use the free element to create hash column for unique
163 constraint.
164
165 RETURN
166 false - OK
167 true - Error
168*/
169
170bool Singular::create_myisam_tmp_table(KeyInfo *keyinfo,
171 MI_COLUMNDEF *start_recinfo,
172 MI_COLUMNDEF **recinfo,
173 uint64_t options)
174{
175 int error;
176 MI_KEYDEF keydef;
177 MI_UNIQUEDEF uniquedef;
178
179 if (getShare()->sizeKeys())
180 { // Get keys for ni_create
181 bool using_unique_constraint= false;
182 HA_KEYSEG *seg= new (mem()) HA_KEYSEG[keyinfo->key_parts];
183
184 memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
185 if (keyinfo->key_length >= cursor->getEngine()->max_key_length() ||
186 keyinfo->key_parts > cursor->getEngine()->max_key_parts() ||
187 getShare()->uniques)
188 {
189 /* Can't create a key; Make a unique constraint instead of a key */
190 getMutableShare()->keys= 0;
191 getMutableShare()->uniques= 1;
192 using_unique_constraint= true;
193 memset(&uniquedef, 0, sizeof(uniquedef));
194 uniquedef.keysegs=keyinfo->key_parts;
195 uniquedef.seg=seg;
196 uniquedef.null_are_equal=1;
197
198 /* Create extra column for hash value */
199 memset(*recinfo, 0, sizeof(**recinfo));
200 (*recinfo)->type= FIELD_CHECK;
201 (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
202 (*recinfo)++;
203 getMutableShare()->setRecordLength(getShare()->getRecordLength() + MI_UNIQUE_HASH_LENGTH);
204 }
205 else
206 {
207 /* Create an unique key */
208 memset(&keydef, 0, sizeof(keydef));
209 keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
210 keydef.keysegs= keyinfo->key_parts;
211 keydef.seg= seg;
212 }
213 for (uint32_t i= 0; i < keyinfo->key_parts ; i++,seg++)
214 {
215 Field *key_field=keyinfo->key_part[i].field;
216 seg->flag= 0;
217 seg->language= key_field->charset()->number;
218 seg->length= keyinfo->key_part[i].length;
219 seg->start= keyinfo->key_part[i].offset;
220 if (key_field->flags & BLOB_FLAG)
221 {
222 seg->type= ((keyinfo->key_part[i].key_type & 1 /* binary */) ?
223 HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);
224 seg->bit_start= (uint8_t)(key_field->pack_length() - getShare()->blob_ptr_size);
225 seg->flag= HA_BLOB_PART;
226 seg->length= 0; // Whole blob in unique constraint
227 }
228 else
229 {
230 seg->type= keyinfo->key_part[i].type;
231 }
232 if (!(key_field->flags & NOT_NULL_FLAG))
233 {
234 seg->null_bit= key_field->null_bit;
235 seg->null_pos= (uint32_t) (key_field->null_ptr - getInsertRecord());
236 /*
237 We are using a GROUP BY on something that contains NULL
238 In this case we have to tell MyISAM that two NULL should
239 on INSERT be regarded at the same value
240 */
241 if (! using_unique_constraint)
242 keydef.flag|= HA_NULL_ARE_EQUAL;
243 }
244 }
245 }
246 MI_CREATE_INFO create_info;
247
248 if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
249 OPTION_BIG_TABLES)
250 create_info.data_file_length= ~(uint64_t) 0;
251
252 if ((error= mi_create(getShare()->getTableName(), getShare()->sizeKeys(), &keydef,
253 (uint32_t) (*recinfo-start_recinfo),
254 start_recinfo,
255 getShare()->uniques, &uniquedef,
256 &create_info,
257 HA_CREATE_TMP_TABLE)))
258 {
259 print_error(error, MYF(0));
260 db_stat= 0;
261
262 return true;
263 }
264 in_use->status_var.created_tmp_disk_tables++;
265 getMutableShare()->db_record_offset= 1;
266 return false;
267}
268
269/*
270 Set up column usage bitmaps for a temporary table
271
272 IMPLEMENTATION
273 For temporary tables, we need one bitmap with all columns set and
274 a tmp_set bitmap to be used by things like filesort.
275*/
276
277void Singular::setup_tmp_table_column_bitmaps()
278{
279 uint32_t field_count= getShare()->sizeFields();
280
281 def_read_set.resize(field_count);
282 def_write_set.resize(field_count);
283 tmp_set.resize(field_count);
284 getMutableShare()->all_set.resize(field_count);
285 getMutableShare()->all_set.set();
286 def_write_set.set();
287 def_read_set.set();
288 default_column_bitmaps();
289}
290
291Singular::~Singular()
292{
293 const char* save_proc_info= in_use->get_proc_info();
294 in_use->set_proc_info("removing tmp table");
295
296 // Release latches since this can take a long time
297 plugin::TransactionalStorageEngine::releaseTemporaryLatches(in_use);
298
299 if (cursor)
300 {
301 if (db_stat)
302 cursor->closeMarkForDelete();
303
304 drizzled::error_t ignored;
305 plugin::StorageEngine::dropTable(*in_use, *getShare()->getEngine(), getShare()->getTableIdentifier(), ignored);
306 delete cursor;
307 }
308
309 /* free blobs */
310 for (Field **ptr= getFields(); *ptr; ptr++)
311 {
312 (*ptr)->free();
313 }
314 free_io_cache();
315
316 mem().free_root(MYF(0));
317 in_use->set_proc_info(save_proc_info);
318}
319
320} /* namespace table */
321} /* namespace drizzled */
TODO: Rename this file - func.h is stupid.