Merge mysql.com:/home/wax/mysql-4n into mysql.com:/home/wax/mysql-4rw

sql/item_func.cc

@@ -1291,11 +1291,11 @@ udf_handler::fix_fields(THD *thd, TABLE_LIST *tables, Item_result_field *func,
   }
   else
     thd=current_thd;				// In WHERE / const clause
-  udf_func *tmp_udf=find_udf(u_d->name,(uint) strlen(u_d->name),1);
+  udf_func *tmp_udf=find_udf(u_d->name.str,(uint) u_d->name.length,1);
 
   if (!tmp_udf)
   {
-    my_printf_error(ER_CANT_FIND_UDF,ER(ER_CANT_FIND_UDF),MYF(0),u_d->name,
+    my_printf_error(ER_CANT_FIND_UDF,ER(ER_CANT_FIND_UDF),MYF(0),u_d->name.str,
 		    errno);
     DBUG_RETURN(1);
   }

sql/sql_parse.cc

@@ -2705,7 +2705,7 @@ mysql_execute_command(THD *thd)
     if (check_access(thd,DELETE_ACL,"mysql",0,1))
       break;
 #ifdef HAVE_DLOPEN
-    if (!(res = mysql_drop_function(thd,lex->udf.name)))
+    if (!(res = mysql_drop_function(thd,&lex->udf.name)))
       send_ok(thd);
 #else
     res= -1;

sql/sql_udf.cc

@@ -74,7 +74,7 @@ static HASH udf_hash;
 static rw_lock_t THR_LOCK_udf;
 
 
-static udf_func *add_udf(char *name, Item_result ret, char *dl,
+static udf_func *add_udf(LEX_STRING *name, Item_result ret, char *dl,
 			 Item_udftype typ);
 static void del_udf(udf_func *udf);
 static void *find_udf_dl(const char *dl);
@@ -84,8 +84,8 @@ static void init_syms(udf_func *tmp)
 {
   char nm[MAX_FIELD_NAME+16],*end;
 
-  tmp->func = dlsym(tmp->dlhandle, tmp->name);
-  end=strmov(nm,tmp->name);
+  tmp->func = dlsym(tmp->dlhandle, tmp->name.str);
+  end=strmov(nm,tmp->name.str);
   (void) strmov(end,"_init");
   tmp->func_init = dlsym(tmp->dlhandle, nm);
   (void) strmov(end,"_deinit");
@@ -103,8 +103,8 @@ extern "C" byte* get_hash_key(const byte *buff,uint *length,
 			      my_bool not_used __attribute__((unused)))
 {
   udf_func *udf=(udf_func*) buff;
-  *length=(uint) udf->name_length;
-  return (byte*) udf->name;
+  *length=(uint) udf->name.length;
+  return (byte*) udf->name.str;
 }
 
 /*
@@ -161,14 +161,16 @@ void udf_init()
   while (!(error = read_record_info.read_record(&read_record_info)))
   {
     DBUG_PRINT("info",("init udf record"));
-    char *name=get_field(&mem, table, 0);
+    LEX_STRING name;
+    name.str=get_field(&mem, table, 0);
+    name.length = strlen(name.str);
     char *dl_name= get_field(&mem, table, 2);
     bool new_dl=0;
     Item_udftype udftype=UDFTYPE_FUNCTION;
     if (table->fields >= 4)			// New func table
       udftype=(Item_udftype) table->field[3]->val_int();
 
-    if (!(tmp = add_udf(name,(Item_result) table->field[1]->val_int(),
+    if (!(tmp = add_udf(&name,(Item_result) table->field[1]->val_int(),
 			dl_name, udftype)))
     {
       sql_print_error("Can't alloc memory for udf function: name");
@@ -250,10 +252,10 @@ static void del_udf(udf_func *udf)
       The functions will be automaticly removed when the least threads
       doesn't use it anymore
     */
-    char *name= udf->name;
-    uint name_length=udf->name_length;
-    udf->name=(char*) "*";
-    udf->name_length=1;
+    char *name= udf->name.str;
+    uint name_length=udf->name.length;
+    udf->name.str=(char*) "*";
+    udf->name.length=1;
     hash_update(&udf_hash,(byte*) udf,(byte*) name,name_length);
   }
   DBUG_VOID_RETURN;
@@ -322,7 +324,7 @@ static void *find_udf_dl(const char *dl)
 
 /* Assume that name && dl is already allocated */
 
-static udf_func *add_udf(char *name, Item_result ret, char *dl,
+static udf_func *add_udf(LEX_STRING *name, Item_result ret, char *dl,
 			 Item_udftype type)
 {
   if (!name || !dl || !(uint) type || (uint) type > (uint) UDFTYPE_AGGREGATE)
@@ -331,8 +333,7 @@ static udf_func *add_udf(char *name, Item_result ret, char *dl,
   if (!tmp)
     return 0;
   bzero((char*) tmp,sizeof(*tmp));
-  tmp->name = name;
-  tmp->name_length=(uint) strlen(tmp->name);
+  tmp->name = *name; //dup !!
   tmp->dl = dl;
   tmp->returns = ret;
   tmp->type = type;
@@ -370,14 +371,14 @@ int mysql_create_function(THD *thd,udf_func *udf)
     send_error(thd, ER_UDF_NO_PATHS,ER(ER_UDF_NO_PATHS));
     DBUG_RETURN(1);
   }
-  if (udf->name_length > NAME_LEN)
+  if (udf->name.length > NAME_LEN)
   {
     net_printf(thd, ER_TOO_LONG_IDENT,udf->name);
     DBUG_RETURN(1);
   }
 
   rw_wrlock(&THR_LOCK_udf);
-  if ((hash_search(&udf_hash,(byte*) udf->name, udf->name_length)))
+  if ((hash_search(&udf_hash,(byte*) udf->name.str, udf->name.length)))
   {
     net_printf(thd, ER_UDF_EXISTS, udf->name);
     goto err;
@@ -401,9 +402,9 @@ int mysql_create_function(THD *thd,udf_func *udf)
     net_printf(thd, ER_CANT_FIND_DL_ENTRY, udf->name);
     goto err;
   }
-  udf->name=strdup_root(&mem,udf->name);
+  udf->name.str=strdup_root(&mem,udf->name.str);
   udf->dl=strdup_root(&mem,udf->dl);
-  if (!(u_d=add_udf(udf->name,udf->returns,udf->dl,udf->type)))
+  if (!(u_d=add_udf(&udf->name,udf->returns,udf->dl,udf->type)))
   {
     send_error(thd,0);		// End of memory
     goto err;
@@ -425,7 +426,7 @@ int mysql_create_function(THD *thd,udf_func *udf)
     goto err;
 
   restore_record(table,2);		// Get default values for fields
-  table->field[0]->store(u_d->name, u_d->name_length, default_charset_info);
+  table->field[0]->store(u_d->name.str, u_d->name.length, default_charset_info);
   table->field[1]->store((longlong) u_d->returns);
   table->field[2]->store(u_d->dl,(uint) strlen(u_d->dl), default_charset_info);
   if (table->fields >= 4)			// If not old func format
@@ -450,7 +451,7 @@ int mysql_create_function(THD *thd,udf_func *udf)
 }
 
 
-int mysql_drop_function(THD *thd,const char *udf_name)
+int mysql_drop_function(THD *thd,const LEX_STRING *udf_name)
 {
   TABLE *table;
   TABLE_LIST tables;
@@ -462,8 +463,8 @@ int mysql_drop_function(THD *thd,const char *udf_name)
     DBUG_RETURN(1);
   }
   rw_wrlock(&THR_LOCK_udf);  
-  if (!(udf=(udf_func*) hash_search(&udf_hash,(byte*) udf_name,
-				    (uint) strlen(udf_name))))
+  if (!(udf=(udf_func*) hash_search(&udf_hash,(byte*) udf_name->str,
+				    (uint) udf_name->length)))
   {
     net_printf(thd, ER_FUNCTION_NOT_DEFINED, udf_name);
     goto err;
@@ -481,8 +482,8 @@ int mysql_drop_function(THD *thd,const char *udf_name)
   tables.real_name= tables.alias= (char*) "func";
   if (!(table = open_ltable(thd,&tables,TL_WRITE)))
     goto err;
-  if (!table->file->index_read_idx(table->record[0],0,(byte*) udf_name,
-				   (uint) strlen(udf_name),
+  if (!table->file->index_read_idx(table->record[0],0,(byte*) udf_name->str,
+				   (uint) udf_name->length,
 				   HA_READ_KEY_EXACT))
   {
     int error;

sql/sql_udf.h

@@ -25,8 +25,7 @@ enum Item_udftype {UDFTYPE_FUNCTION=1,UDFTYPE_AGGREGATE};
 
 typedef struct st_udf_func
 {
-  char *name;
-  int name_length;
+  LEX_STRING name;
   Item_result returns;
   Item_udftype type;
   char *dl;
@@ -61,7 +60,7 @@ class udf_handler :public Sql_alloc
     initialized(0)
   {}
   ~udf_handler();
-  const char *name() const { return u_d ? u_d->name : "?"; }
+  const char *name() const { return u_d ? u_d->name.str : "?"; }
   Item_result result_type () const
   { return u_d	? u_d->returns : STRING_RESULT;}
   bool get_arguments();
@@ -140,5 +139,5 @@ void udf_init(void),udf_free(void);
 udf_func *find_udf(const char *name, uint len=0,bool mark_used=0);
 void free_udf(udf_func *udf);
 int mysql_create_function(THD *thd,udf_func *udf);
-int mysql_drop_function(THD *thd,const char *name);
+int mysql_drop_function(THD *thd,const LEX_STRING *name);
 #endif

sql/sql_yacc.yy

@@ -870,12 +870,11 @@ create:
 	    lex->name=$4.str;
             lex->create_info.options=$3;
 	  }
-	| CREATE udf_func_type UDF_SYM ident
+	| CREATE udf_func_type UDF_SYM IDENT
 	  {
 	    LEX *lex=Lex;
 	    lex->sql_command = SQLCOM_CREATE_FUNCTION;
-	    lex->udf.name=$4.str;
-	    lex->udf.name_length=$4.length;
+	    lex->udf.name = $4;
 	    lex->udf.type= $2;
 	  }
 	  UDF_RETURNS_SYM udf_type UDF_SONAME_SYM TEXT_STRING
@@ -3013,11 +3012,11 @@ drop:
 	    lex->drop_if_exists=$3;
 	    lex->name=$4.str;
 	 }
-	| DROP UDF_SYM ident
+	| DROP UDF_SYM IDENT
 	  {
 	    LEX *lex=Lex;
 	    lex->sql_command = SQLCOM_DROP_FUNCTION;
-	    lex->udf.name=$3.str;
+	    lex->udf.name = $3;
 	  };