← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/pbms_enabled.cc

  • Committer: Daniel Nichter
  • Date: 2011-10-23 16:01:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2448.
  • Revision ID: daniel@percona.com-20111023160137-7ac3blgz8z4tf8za
Add Administration Getting Started and Logging.  Capitalize SQL clause keywords.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/pbms_enabled.cc
 
1
/* Copyright (C) 2010 PrimeBase Technologies GmbH
 
2
 * All rights reserved.
 
3
 * 
 
4
 * Redistribution and use in source and binary forms, with or without 
 
5
 * modification, are permitted provided that the following conditions are met:
 
6
 * 
 
7
 *     * Redistributions of source code must retain the above copyright notice, 
 
8
 *              this list of conditions and the following disclaimer.
 
9
 *     * Redistributions in binary form must reproduce the above copyright notice, 
 
10
 *              this list of conditions and the following disclaimer in the documentation 
 
11
 *              and/or other materials provided with the distribution.
 
12
 *     * Neither the name of the "PrimeBase Technologies GmbH" nor the names of its 
 
13
 *              contributors may be used to endorse or promote products derived from this 
 
14
 *              software without specific prior written permission.
 
15
 * 
 
16
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
 
17
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
 
18
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
 
19
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
 
20
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
 
21
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 
22
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 
23
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 
24
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 
25
 * POSSIBILITY OF SUCH DAMAGE. 
 
26
 *  
 
27
 *
 
28
 * PrimeBase Media Stream for MySQL and Drizzle
 
29
 *
 
30
 *
 
31
 * Barry Leslie
 
32
 *
 
33
 * 2009-07-16
 
34
 *
 
35
 * H&G2JCtL
 
36
 *
 
37
 * PBMS interface used to enable engines for use with the PBMS daemon.
 
38
 *
 
39
 * For an example on how to build this into an engine have a look at the PBXT engine
 
40
 * in file ha_pbxt.cc. Search for 'PBMS_ENABLED'.
 
41
 *
 
42
 */
 
43
 
 
44
#ifndef DRIZZLED
 
45
#if defined(MSDOS) || defined(__WIN__)
 
46
#include "pbms_enabled.h"
 
47
 
 
48
// Windows is not supported yet so just stub out the functions..
 
49
bool pbms_initialize(const char *engine_name __attribute__((unused)), 
 
50
                                        bool isServer __attribute__((unused)), 
 
51
                                        bool isTransactional __attribute__((unused)), 
 
52
                                        PBMSResultPtr result __attribute__((unused)), 
 
53
                                        IsPBMSFilterFunc is_pbms_blob __attribute__((unused))
 
54
                                        ) { return true;}
 
55
void pbms_finalize() {}
 
56
int pbms_write_row_blobs(const TABLE *table __attribute__((unused)), 
 
57
                                                unsigned char *buf __attribute__((unused)), 
 
58
                                                PBMSResultPtr result __attribute__((unused))
 
59
                                                ){ return 0;}
 
60
int pbms_update_row_blobs(const TABLE *table __attribute__((unused)), 
 
61
                                                const unsigned char *old_row __attribute__((unused)), 
 
62
                                                unsigned char *new_row __attribute__((unused)), 
 
63
                                                PBMSResultPtr result __attribute__((unused))
 
64
                                                ){ return 0;}
 
65
int pbms_delete_row_blobs(const TABLE *table __attribute__((unused)), 
 
66
                                                const unsigned char *buf __attribute__((unused)), 
 
67
                                                PBMSResultPtr result __attribute__((unused))
 
68
                                                ){ return 0;}
 
69
int pbms_rename_table_with_blobs(const char *old_table_path __attribute__((unused)), 
 
70
                                                                const char *new_table_path __attribute__((unused)), 
 
71
                                                                PBMSResultPtr result __attribute__((unused))
 
72
                                                                ){ return 0;}
 
73
int pbms_delete_table_with_blobs(const char *table_path __attribute__((unused)), 
 
74
                                                                PBMSResultPtr result __attribute__((unused))
 
75
                                                                ){ return 0;}
 
76
void pbms_completed(TABLE *table __attribute__((unused)), 
 
77
                                        bool ok __attribute__((unused))
 
78
                                        ){}
 
79
#else
 
80
#define PBMS_API        pbms_enabled_api
 
81
 
 
82
#include "pbms_enabled.h"
 
83
#include "mysql_priv.h"
 
84
#include <mysql/plugin.h>
 
85
#define session_alloc(sess, size) thd_alloc(sess, size);
 
86
#define current_session current_thd
 
87
 
 
88
#define GET_BLOB_FIELD(t, i) (Field_blob *)(t->field[t->s->blob_field[i]])
 
89
#define DB_NAME(f) (f->table->s->db.str)
 
90
#define TAB_NAME(f) (*(f->table_name))
 
91
 
 
92
static PBMS_API pbms_api;
 
93
 
 
94
/* 
 
95
 * A callback function to check if the column is a PBMS BLOB. 
 
96
 * Can be NULL if no check is to be done. 
 
97
 */ 
 
98
static IsPBMSFilterFunc is_pbms_blob = NULL; 
 
99
 
 
100
//====================
 
101
bool pbms_initialize(const char *engine_name, bool isServer, bool isTransactional, PBMSResultPtr result, IsPBMSFilterFunc is_pbms_blob_arg)
 
102
{
 
103
        int     err;
 
104
        PBMSEngineRec enabled_engine = {
 
105
                MS_ENGINE_VERSION,
 
106
                0,
 
107
                0,
 
108
                0,
 
109
                {0},    
 
110
                0
 
111
        };
 
112
 
 
113
        strncpy(enabled_engine.ms_engine_name, engine_name, 32);
 
114
        enabled_engine.ms_internal = isServer;
 
115
        enabled_engine.ms_has_transactions = isTransactional;
 
116
        enabled_engine.ms_engine_name[31] = 0;
 
117
 
 
118
        err = pbms_api.registerEngine(&enabled_engine, result);
 
119
        is_pbms_blob = is_pbms_blob_arg;
 
120
 
 
121
        return (err == 0);
 
122
}
 
123
 
 
124
 
 
125
//====================
 
126
void pbms_finalize(const char *engine_name)
 
127
{
 
128
        pbms_api.deregisterEngine(engine_name);
 
129
}
 
130
 
 
131
//==================================
 
132
static int insertRecord(Field_blob *field, char *blob,  size_t org_length, unsigned char *blob_rec, size_t packlength, PBMSResultPtr result)
 
133
{
 
134
        int err;
 
135
        size_t length;
 
136
        PBMSBlobURLRec blob_url;
 
137
        
 
138
        err = pbms_api.retainBlob(DB_NAME(field), TAB_NAME(field), &blob_url, blob, org_length, field->position(), result);
 
139
        if (err)
 
140
                return err;
 
141
                
 
142
        // If the BLOB length changed reset it. 
 
143
        // This will happen if the BLOB data was replaced with a BLOB reference. 
 
144
        length = strlen(blob_url.bu_data)  +1;
 
145
        if ((length != org_length) || memcmp(blob_url.bu_data, blob, length)) {
 
146
                if (length != org_length) {
 
147
                        field->store_length(blob_rec, packlength, length);
 
148
                }
 
149
                
 
150
                if (length > org_length) {
 
151
                        // This can only happen if the BLOB URL is actually larger than the BLOB itself.
 
152
                        blob = (char *) session_alloc(current_session, length);
 
153
                        memcpy(blob_rec+packlength, &blob, sizeof(char*));
 
154
                }                       
 
155
                memcpy(blob, blob_url.bu_data, length);
 
156
        } 
 
157
                
 
158
        return 0;
 
159
}
 
160
 
 
161
//====================
 
162
int pbms_update_row_blobs(const TABLE *table, const unsigned char *old_row, unsigned char *new_row, PBMSResultPtr result)
 
163
{
 
164
        Field_blob *field;
 
165
        uint32_t field_offset;
 
166
        const unsigned char *old_blob_rec;
 
167
        unsigned char *new_blob_rec;
 
168
        char *old_blob_url, *new_blob_url;
 
169
        size_t packlength, i, old_length, new_length;
 
170
        int err;
 
171
        bool old_null_blob, new_null_blob;
 
172
 
 
173
        result->mr_had_blobs = false;
 
174
        
 
175
        if (!pbms_api.isPBMSLoaded())
 
176
                return 0;
 
177
                
 
178
        if (table->s->blob_fields == 0)
 
179
                return 0;
 
180
                
 
181
        for (i= 0; i < table->s->blob_fields; i++) {
 
182
                field = GET_BLOB_FIELD(table, i);
 
183
 
 
184
                old_null_blob = field->is_null_in_record(old_row);
 
185
                new_null_blob = field->is_null_in_record(new_row);
 
186
                if (old_null_blob && new_null_blob)
 
187
                        continue;
 
188
 
 
189
                {
 
190
                        String type_name;
 
191
                        // Note: field->type() always returns MYSQL_TYPE_BLOB regardless of the type of BLOB
 
192
                        field->sql_type(type_name);
 
193
                        if (strcasecmp(type_name.c_ptr(), "LongBlob"))
 
194
                                continue;
 
195
                }
 
196
                        
 
197
                if( is_pbms_blob && !is_pbms_blob(field) )
 
198
                        continue;
 
199
                        
 
200
                        
 
201
                // Get the blob record:
 
202
                field_offset = field->offset(field->table->record[0]);
 
203
                packlength = field->pack_length() - field->table->s->blob_ptr_size;
 
204
 
 
205
                if (new_null_blob) {
 
206
                        new_blob_url = NULL;
 
207
                } else {
 
208
                        new_blob_rec = new_row + field_offset;
 
209
                        new_length = field->get_length(new_blob_rec);
 
210
                        memcpy(&new_blob_url, new_blob_rec +packlength, sizeof(char*));
 
211
                }
 
212
                
 
213
                if (old_null_blob) {
 
214
                        old_blob_url = NULL;
 
215
                } else {
 
216
                        old_blob_rec = old_row + field_offset;
 
217
                        old_length = field->get_length(old_blob_rec);
 
218
                        memcpy(&old_blob_url, old_blob_rec +packlength, sizeof(char*));
 
219
                }
 
220
                
 
221
                // Check to see if the BLOBs are the same.
 
222
                // I am assuming that if the BLOB pointer is different then teh BLOB has changed.
 
223
                // Zero length BLOBs are a special case because they may have a NULL data pointer,
 
224
                // to catch this and distiguish it from a NULL BLOB I do a check to see if one field was NULL:
 
225
                // (old_null_blob != new_null_blob)
 
226
                if ((old_blob_url != new_blob_url) || (old_null_blob != new_null_blob)) {
 
227
                        
 
228
                        result->mr_had_blobs = true;
 
229
 
 
230
                        // The BLOB was updated so delete the old one and insert the new one.
 
231
                        if ((old_null_blob == false) && (err = pbms_api.releaseBlob(DB_NAME(field), TAB_NAME(field), old_blob_url, old_length, result)))
 
232
                                return err;
 
233
                                
 
234
                        if ((new_null_blob == false) && (err = insertRecord(field, new_blob_url, new_length, new_blob_rec, packlength, result)))
 
235
                                return err;
 
236
                } 
 
237
        }
 
238
        
 
239
        return 0;
 
240
}
 
241
 
 
242
//====================
 
243
int pbms_write_row_blobs(const TABLE *table, unsigned char *row_buffer, PBMSResultPtr result)
 
244
{
 
245
 
 
246
        Field_blob *field;
 
247
        unsigned char *blob_rec;
 
248
        char *blob_url;
 
249
        size_t packlength, i, length;
 
250
        int err;
 
251
 
 
252
        result->mr_had_blobs = false;
 
253
 
 
254
        if (!pbms_api.isPBMSLoaded())
 
255
                return 0;
 
256
                
 
257
        if (table->s->blob_fields == 0)
 
258
                return 0;
 
259
                
 
260
        for (i= 0; i <  table->s->blob_fields; i++) {
 
261
                field =  GET_BLOB_FIELD(table, i);
 
262
                
 
263
                if (field->is_null_in_record(row_buffer))
 
264
                        continue;
 
265
                        
 
266
                {
 
267
                        String type_name;
 
268
                        // Note: field->type() always returns MYSQL_TYPE_BLOB regardless of the type of BLOB
 
269
                        field->sql_type(type_name);
 
270
                        if (strcasecmp(type_name.c_ptr(), "LongBlob"))
 
271
                                continue;
 
272
                }
 
273
                        
 
274
                if( is_pbms_blob && !is_pbms_blob(field) )
 
275
                        continue;
 
276
 
 
277
                result->mr_had_blobs = true;
 
278
 
 
279
                // Get the blob record:
 
280
                packlength = field->pack_length() - field->table->s->blob_ptr_size;
 
281
                blob_rec = row_buffer + field->offset(field->table->record[0]);
 
282
                
 
283
                length = field->get_length(blob_rec);
 
284
                memcpy(&blob_url, blob_rec +packlength, sizeof(char*));
 
285
 
 
286
                if ((err = insertRecord(field, blob_url, length, blob_rec, packlength, result)))
 
287
                        return err;
 
288
        }
 
289
 
 
290
        return 0;
 
291
}
 
292
 
 
293
//====================
 
294
int pbms_delete_row_blobs(const TABLE *table, const unsigned char *row_buffer, PBMSResultPtr result)
 
295
{
 
296
        Field_blob *field;
 
297
        const unsigned char *blob_rec;
 
298
        char *blob;
 
299
        size_t packlength, i, length;
 
300
        bool call_failed = false;
 
301
        int err;
 
302
        
 
303
        result->mr_had_blobs = false;
 
304
 
 
305
        if (!pbms_api.isPBMSLoaded())
 
306
                return 0;
 
307
                
 
308
        if (table->s->blob_fields == 0)
 
309
                return 0;
 
310
                
 
311
        for (i= 0; i < table->s->blob_fields; i++) {
 
312
                field = GET_BLOB_FIELD(table, i);
 
313
                
 
314
                if (field->is_null_in_record(row_buffer))
 
315
                        continue;
 
316
                        
 
317
                {
 
318
                        String type_name;
 
319
                        // Note: field->type() always returns MYSQL_TYPE_BLOB regardless of the type of BLOB
 
320
                        field->sql_type(type_name);
 
321
                        if (strcasecmp(type_name.c_ptr(), "LongBlob"))
 
322
                                continue;
 
323
                }
 
324
                        
 
325
                if(is_pbms_blob && !is_pbms_blob(field) )
 
326
                        continue;
 
327
 
 
328
                result->mr_had_blobs = true;    
 
329
                
 
330
                // Get the blob record:
 
331
                packlength = field->pack_length() - field->table->s->blob_ptr_size;
 
332
 
 
333
                blob_rec = row_buffer + field->offset(field->table->record[0]);
 
334
                length = field->get_length(blob_rec);
 
335
                memcpy(&blob, blob_rec +packlength, sizeof(char*));
 
336
 
 
337
                // Signal PBMS to delete the reference to the BLOB.
 
338
                err = pbms_api.releaseBlob(DB_NAME(field), TAB_NAME(field), blob, length, result);
 
339
                if (err)
 
340
                        return err;
 
341
        }
 
342
        
 
343
        return 0;
 
344
}
 
345
 
 
346
#define MAX_NAME_SIZE 64
 
347
static void parse_table_path(const char *path, char *db_name, char *tab_name)
 
348
{
 
349
        const char *ptr = path + strlen(path) -1, *eptr;
 
350
        int len;
 
351
        
 
352
        *db_name = *tab_name = 0;
 
353
        
 
354
        while ((ptr > path) && (*ptr != '/'))ptr --;
 
355
        if (*ptr != '/') 
 
356
                return;
 
357
                
 
358
        strncpy(tab_name, ptr+1, MAX_NAME_SIZE);
 
359
        tab_name[MAX_NAME_SIZE-1] = 0;
 
360
        eptr = ptr;
 
361
        ptr--;
 
362
        
 
363
        while ((ptr > path) && (*ptr != '/'))ptr --;
 
364
        if (*ptr != '/') 
 
365
                return;
 
366
        ptr++;
 
367
        
 
368
        len = eptr - ptr;
 
369
        if (len >= MAX_NAME_SIZE)
 
370
                len = MAX_NAME_SIZE-1;
 
371
                
 
372
        memcpy(db_name, ptr, len);
 
373
        db_name[len] = 0;
 
374
        
 
375
}
 
376
 
 
377
//====================
 
378
int pbms_rename_table_with_blobs(const char *old_table_path, const char *new_table_path, PBMSResultPtr result)
 
379
{
 
380
        char o_db_name[MAX_NAME_SIZE], n_db_name[MAX_NAME_SIZE], o_tab_name[MAX_NAME_SIZE], n_tab_name[MAX_NAME_SIZE];
 
381
 
 
382
        result->mr_had_blobs = false; 
 
383
        if (!pbms_api.isPBMSLoaded())
 
384
                return 0;
 
385
                
 
386
        result->mr_had_blobs = true; // Assume it has blobs.
 
387
        
 
388
        parse_table_path(old_table_path, o_db_name, o_tab_name);
 
389
        parse_table_path(new_table_path, n_db_name, n_tab_name);
 
390
        
 
391
        return pbms_api.renameTable(o_db_name, o_tab_name, n_db_name, n_tab_name, result);
 
392
}
 
393
 
 
394
//====================
 
395
int pbms_delete_table_with_blobs(const char *table_path, PBMSResultPtr result)
 
396
{
 
397
        char db_name[MAX_NAME_SIZE], tab_name[MAX_NAME_SIZE];
 
398
                
 
399
        result->mr_had_blobs = false; 
 
400
        if (!pbms_api.isPBMSLoaded())
 
401
                return 0;
 
402
                
 
403
        result->mr_had_blobs = true; // Assume it has blobs.
 
404
        parse_table_path(table_path, db_name, tab_name);
 
405
 
 
406
        return pbms_api.dropTable(db_name, tab_name, result);
 
407
}
 
408
 
 
409
//====================
 
410
void pbms_completed(const TABLE *table, bool ok)
 
411
{
 
412
        if (!pbms_api.isPBMSLoaded())
 
413
                return;
 
414
                
 
415
        if ((!table) || (table->s->blob_fields != 0))
 
416
                pbms_api.completed(ok) ;
 
417
                
 
418
         return ;
 
419
}
 
420
#endif
 
421
#endif // DRIZZLED