← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/sql_udf.cc

  • Committer: Brian Aker
  • Date: 2008-07-08 16:53:50 UTC
  • mfrom: (51.1.8 remove-dbug)
  • Revision ID: brian@tangent.org-20080708165350-y246k7585xv56c0m
Merging in Jay's Tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/sql_udf.cc
108
108
  READ_RECORD read_record_info;
109
109
  TABLE *table;
110
110
  int error;
111
 
  DBUG_ENTER("ufd_init");
 
111
  
112
112
  char db[]= "mysql"; /* A subject to casednstr, can't be constant */
113
113
 
114
114
  if (initialized)
115
 
    DBUG_VOID_RETURN;
 
115
    return;
116
116
 
117
117
  my_rwlock_init(&THR_LOCK_udf,NULL);
118
118
  
125
125
    hash_free(&udf_hash);
126
126
    free_root(&mem,MYF(0));
127
127
    delete new_thd;
128
 
    DBUG_VOID_RETURN;
 
128
    return;
129
129
  }
130
130
 
131
131
  initialized = 1;
132
 
 
133
132
  close_thread_tables(new_thd);
134
133
  delete new_thd;
135
134
  /* Remember that we don't have a THD */
136
135
  my_pthread_setspecific_ptr(THR_THD,  0);
137
 
  DBUG_VOID_RETURN;
 
136
  return;
138
137
}
139
138
 
140
139
 
141
140
void udf_free()
142
141
{
143
142
  /* close all shared libraries */
144
 
  DBUG_ENTER("udf_free");
 
143
  
145
144
  for (uint idx=0 ; idx < udf_hash.records ; idx++)
146
145
  {
147
146
    udf_func *udf=(udf_func*) hash_element(&udf_hash,idx);
164
163
    initialized= 0;
165
164
    rwlock_destroy(&THR_LOCK_udf);
166
165
  }
167
 
  DBUG_VOID_RETURN;
 
166
  return;
168
167
}
169
168
 
170
169
 
171
170
static void del_udf(udf_func *udf)
172
171
{
173
 
  DBUG_ENTER("del_udf");
 
172
  
174
173
  if (!--udf->usage_count)
175
174
  {
176
175
    hash_delete(&udf_hash,(uchar*) udf);
189
188
    udf->name.length=1;
190
189
    hash_update(&udf_hash,(uchar*) udf,(uchar*) name,name_length);
191
190
  }
192
 
  DBUG_VOID_RETURN;
 
191
  return;
193
192
}
194
193
 
195
194
 
196
195
void free_udf(udf_func *udf)
197
196
{
198
 
  DBUG_ENTER("free_udf");
 
197
  
199
198
  
200
199
  if (!initialized)
201
 
    DBUG_VOID_RETURN;
 
200
    return;
202
201
 
203
202
  rw_wrlock(&THR_LOCK_udf);
204
203
  if (!--udf->usage_count)
213
212
      dlclose(udf->dlhandle);
214
213
  }
215
214
  rw_unlock(&THR_LOCK_udf);
216
 
  DBUG_VOID_RETURN;
 
215
  return;
217
216
}
218
217
 
219
218
 
222
221
udf_func *find_udf(const char *name,uint length,bool mark_used)
223
222
{
224
223
  udf_func *udf=0;
225
 
  DBUG_ENTER("find_udf");
 
224
  
226
225
 
227
226
  if (!initialized)
228
 
    DBUG_RETURN(NULL);
 
227
    return(NULL);
229
228
 
230
229
  /* TODO: This should be changed to reader locks someday! */
231
230
  if (mark_used)
242
241
      udf->usage_count++;
243
242
  }
244
243
  rw_unlock(&THR_LOCK_udf);
245
 
  DBUG_RETURN(udf);
 
244
  return(udf);
246
245
}
247
246
 
248
247
 
249
248
static void *find_udf_dl(const char *dl)
250
249
{
251
 
  DBUG_ENTER("find_udf_dl");
 
250
  
252
251
 
253
252
  /*
254
253
    Because only the function name is hashed, we have to search trough
258
257
  {
259
258
    udf_func *udf=(udf_func*) hash_element(&udf_hash,idx);
260
259
    if (!strcmp(dl, udf->dl) && udf->dlhandle != NULL)
261
 
      DBUG_RETURN(udf->dlhandle);
 
260
      return(udf->dlhandle);
262
261
  }
263
 
  DBUG_RETURN(0);
 
262
  return(0);
264
263
}
265
264
 
266
265
 
303
302
  TABLE *table;
304
303
  TABLE_LIST tables;
305
304
  udf_func *u_d;
306
 
  DBUG_ENTER("mysql_create_function");
 
305
  
307
306
 
308
307
  if (!initialized)
309
308
  {
313
312
               "UDFs are unavailable with the --skip-grant-tables option");
314
313
    else
315
314
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
316
 
    DBUG_RETURN(1);
 
315
    return(1);
317
316
  }
318
317
 
319
318
  /*
329
328
                       udf->dl + strlen(udf->dl), '/'), 0))
330
329
  {
331
330
    my_message(ER_UDF_NO_PATHS, ER(ER_UDF_NO_PATHS), MYF(0));
332
 
    DBUG_RETURN(1);
 
331
    return(1);
333
332
  }
334
333
  if (check_identifier_name(&udf->name, ER_TOO_LONG_IDENT))
335
 
    DBUG_RETURN(1);
 
334
    return(1);
336
335
 
337
336
  /* 
338
337
    Turn off row binlogging of this statement and use statement-based 
353
352
    strxnmov(dlpath, sizeof(dlpath) - 1, opt_plugin_dir, "/", udf->dl, NullS);
354
353
    if (!(dl = dlopen(dlpath, RTLD_NOW)))
355
354
    {
356
 
      DBUG_PRINT("error",("dlopen of %s failed, error: %d (%s)",
357
 
                          udf->dl, errno, dlerror()));
358
355
      my_error(ER_CANT_OPEN_LIBRARY, MYF(0),
359
356
               udf->dl, errno, dlerror());
360
357
      goto err;
409
406
  /* Binlog the create function. */
410
407
  write_bin_log(thd, TRUE, thd->query, thd->query_length);
411
408
 
412
 
  DBUG_RETURN(0);
 
409
  return(0);
413
410
 
414
411
 err:
415
412
  if (new_dl)
416
413
    dlclose(dl);
417
414
  rw_unlock(&THR_LOCK_udf);
418
 
  DBUG_RETURN(1);
 
415
  return(1);
419
416
}
420
417
 
421
418
 
426
423
  udf_func *udf;
427
424
  char *exact_name_str;
428
425
  uint exact_name_len;
429
 
  DBUG_ENTER("mysql_drop_function");
 
426
  
430
427
 
431
428
  if (!initialized)
432
429
  {
434
431
      my_error(ER_FUNCTION_NOT_DEFINED, MYF(0), udf_name->str);
435
432
    else
436
433
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
437
 
    DBUG_RETURN(1);
 
434
    return(1);
438
435
  }
439
436
 
440
437
  /* 
484
481
  /* Binlog the drop function. */
485
482
  write_bin_log(thd, TRUE, thd->query, thd->query_length);
486
483
 
487
 
  DBUG_RETURN(0);
 
484
  return(0);
488
485
 err:
489
486
  rw_unlock(&THR_LOCK_udf);
490
 
  DBUG_RETURN(1);
 
487
  return(1);
491
488
}
492
489
 
493
490
#endif /* HAVE_DLOPEN */