MRN_API char *mroonga_command(UDF_INIT *initid, UDF_ARGS *args, char *result,
unsigned long *length, char *is_null, char *error)
{
CommandInfo *info = (CommandInfo *)initid->ptr;
grn_ctx *ctx = &(info->ctx);
char *command;
unsigned int command_length;
int flags = 0;
if (!args->args[0]) {
*is_null = 1;
return NULL;
}
*is_null = 0;
command = args->args[0];
command_length = args->lengths[0];
grn_ctx_send(ctx, command, command_length, 0);
if (ctx->rc) {
my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
goto error;
}
info->result.length(0);
do {
char *buffer;
unsigned int buffer_length;
grn_ctx_recv(ctx, &buffer, &buffer_length, &flags);
if (ctx->rc) {
my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
goto error;
}
if (buffer_length > 0) {
if (info->result.reserve(buffer_length)) {
my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
goto error;
}
info->result.q_append(buffer, buffer_length);
}
} while (flags & GRN_CTX_MORE);
*length = info->result.length();
return (char *)(info->result.ptr());
error:
*error = 1;
return NULL;
}
MRN_API char *mroonga_escape(UDF_INIT *initid, UDF_ARGS *args, char *result,
unsigned long *length, char *is_null, char *error)
{
EscapeInfo *info = (EscapeInfo *)initid->ptr;
grn_ctx *ctx = &(info->ctx);
if (!args->args[0]) {
*is_null = 1;
return NULL;
}
*is_null = 0;
escape(info, args);
if (ctx->rc) {
my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
goto error;
}
*length = GRN_TEXT_LEN(&(info->escaped_query));
return (char *)(GRN_TEXT_VALUE(&(info->escaped_query)));
error:
*error = 1;
return NULL;
}
int get_topics_for_keyword(THD *thd, TABLE *topics, TABLE *relations,
struct st_find_field *find_fields, int16 key_id,
List<String> *names,
String *name, String *description, String *example)
{
uchar buff[8]; // Max int length
int count= 0;
int iindex_topic, iindex_relations;
Field *rtopic_id, *rkey_id;
DBUG_ENTER("get_topics_for_keyword");
if ((iindex_topic= find_type((char*) primary_key_name,
&topics->s->keynames, 1+2)-1)<0 ||
(iindex_relations= find_type((char*) primary_key_name,
&relations->s->keynames, 1+2)-1)<0)
{
my_message(ER_CORRUPT_HELP_DB, ER(ER_CORRUPT_HELP_DB), MYF(0));
DBUG_RETURN(-1);
}
rtopic_id= find_fields[help_relation_help_topic_id].field;
rkey_id= find_fields[help_relation_help_keyword_id].field;
topics->file->ha_index_init(iindex_topic,1);
relations->file->ha_index_init(iindex_relations,1);
rkey_id->store((longlong) key_id, TRUE);
rkey_id->get_key_image(buff, rkey_id->pack_length(), Field::itRAW);
int key_res= relations->file->index_read_map(relations->record[0],
buff, (key_part_map) 1,
HA_READ_KEY_EXACT);
for ( ;
!key_res && key_id == (int16) rkey_id->val_int() ;
key_res= relations->file->index_next(relations->record[0]))
{
uchar topic_id_buff[8];
longlong topic_id= rtopic_id->val_int();
Field *field= find_fields[help_topic_help_topic_id].field;
field->store((longlong) topic_id, TRUE);
field->get_key_image(topic_id_buff, field->pack_length(), Field::itRAW);
if (!topics->file->index_read_map(topics->record[0], topic_id_buff,
(key_part_map)1, HA_READ_KEY_EXACT))
{
memorize_variant_topic(thd,topics,count,find_fields,
names,name,description,example);
count++;
}
}
topics->file->ha_index_end();
relations->file->ha_index_end();
DBUG_RETURN(count);
}
MRN_API char *mroonga_normalize(UDF_INIT *initid, UDF_ARGS *args, char *result,
unsigned long *length, char *is_null, char *error)
{
st_mrn_normalize_info *info = (st_mrn_normalize_info *)initid->ptr;
grn_ctx *ctx = info->ctx;
String *result_str = &(info->result_str);
if (!args->args[0]) {
*is_null = 1;
return NULL;
}
result_str->length(0);
{
char *target = args->args[0];
unsigned int target_length = args->lengths[0];
grn_obj *grn_string;
const char *normalized;
unsigned int normalized_length_in_bytes;
unsigned int normalized_n_characters;
grn_string = grn_string_open(ctx,
target, target_length,
info->normalizer, info->flags);
grn_string_get_normalized(ctx, grn_string,
&normalized,
&normalized_length_in_bytes,
&normalized_n_characters);
if (result_str->reserve(normalized_length_in_bytes)) {
my_error(ER_OUT_OF_RESOURCES, MYF(0), HA_ERR_OUT_OF_MEM);
goto error;
}
result_str->q_append(normalized, normalized_length_in_bytes);
result_str->length(normalized_length_in_bytes);
grn_obj_unlink(ctx, grn_string);
}
*is_null = 0;
if (ctx->rc) {
my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
goto error;
}
*length = result_str->length();
return (char *)result_str->ptr();
error:
*is_null = 1;
*error = 1;
return NULL;
}
/**************************************************************************
Alloc struct for use with unbuffered reads. Data is fetched by domand
when calling to mysql_fetch_row.
mysql_data_seek is a noop.
No other queries may be specified with the same MYSQL handle.
There shouldn't be much processing per row because mysql server shouldn't
have to wait for the client (and will not wait more than 30 sec/packet).
NOTE: copied from client.c cli_use_result
**************************************************************************/
static MYSQL_RES *connect_use_result(MYSQL *mysql)
{
MYSQL_RES *result;
DBUG_ENTER("connect_use_result");
if (!mysql->fields)
DBUG_RETURN(NULL);
if (mysql->status != MYSQL_STATUS_GET_RESULT) {
my_message(ER_UNKNOWN_ERROR, "Command out of sync", MYF(0));
DBUG_RETURN(NULL);
} // endif status
if (!(result = (MYSQL_RES*) my_malloc(sizeof(*result) +
sizeof(ulong) * mysql->field_count,
MYF(MY_WME | MY_ZEROFILL))))
DBUG_RETURN(NULL);
result->lengths = (ulong*)(result+1);
result->methods = mysql->methods;
/* Ptrs: to one row */
if (!(result->row = (MYSQL_ROW)my_malloc(sizeof(result->row[0]) *
(mysql->field_count+1), MYF(MY_WME)))) {
my_free(result);
DBUG_RETURN(NULL);
} // endif row
result->fields = mysql->fields;
result->field_alloc = mysql->field_alloc;
result->field_count = mysql->field_count;
result->current_field = 0;
result->handle = mysql;
result->current_row = 0;
mysql->fields = 0; /* fields is now in result */
clear_alloc_root(&mysql->field_alloc);
mysql->status = MYSQL_STATUS_USE_RESULT;
mysql->unbuffered_fetch_owner = &result->unbuffered_fetch_cancelled;
DBUG_RETURN(result); /* Data is ready to be fetched */
} // end of connect_use_result
MRN_API char *mroonga_query_expand(UDF_INIT *init,
UDF_ARGS *args,
char *result,
unsigned long *length,
char *is_null,
char *error)
{
MRN_DBUG_ENTER_FUNCTION();
mrn::QueryExpandInfo *info =
reinterpret_cast<mrn::QueryExpandInfo *>(init->ptr);
grn_ctx *ctx = info->ctx;
if (!args->args[3]) {
*is_null = 1;
DBUG_RETURN(NULL);
}
*is_null = 0;
query_expand(info, args);
if (ctx->rc) {
char message[MYSQL_ERRMSG_SIZE];
snprintf(message, MYSQL_ERRMSG_SIZE,
"mroonga_query_expand(): "
"failed to expand: %s",
ctx->errbuf);
my_message(ER_ERROR_ON_WRITE, message, MYF(0));
goto error;
}
*length = GRN_TEXT_LEN(&(info->expanded_query));
DBUG_RETURN(GRN_TEXT_VALUE(&(info->expanded_query)));
error:
*error = 1;
DBUG_RETURN(NULL);
}
gptr _mymalloc (uint uSize, const char *sFile, uint uLine, myf MyFlags)
{
struct remember *pTmp;
DBUG_ENTER("_mymalloc");
DBUG_PRINT("enter",("Size: %u",uSize));
if (!sf_malloc_quick)
(void) _sanity (sFile, uLine);
if(uSize + lCurMemory > safemalloc_mem_limit)
pTmp = 0;
else
/* Allocate the physical memory */
pTmp = (struct remember *) malloc (
sizeof (struct irem) /* remember data */
+ sf_malloc_prehunc
+ uSize /* size requested */
+ 4 /* overrun mark */
+ sf_malloc_endhunc
);
/* Check if there isn't anymore memory avaiable */
if (pTmp == NULL)
{
if (MyFlags & MY_FAE)
error_handler_hook=fatal_error_handler_hook;
if (MyFlags & (MY_FAE+MY_WME))
{
char buff[SC_MAXWIDTH];
my_errno=errno;
sprintf(buff,"Out of memory at line %d, '%s'", uLine, sFile);
my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
sprintf(buff,"needed %d byte (%ldk), memory in use: %ld bytes (%ldk)",
uSize, (uSize + 1023L) / 1024L,
lMaxMemory, (lMaxMemory + 1023L) / 1024L);
my_message(EE_OUTOFMEMORY,buff,MYF(ME_BELL+ME_WAITTANG));
}
DBUG_PRINT("error",("Out of memory, in use: %ld at line %d, '%s'",
lMaxMemory,uLine, sFile));
if (MyFlags & MY_FAE)
exit(1);
DBUG_RETURN ((gptr) NULL);
}
/* Fill up the structure */
*((long*) ((char*) &pTmp -> lSpecialValue+sf_malloc_prehunc)) = MAGICKEY;
pTmp -> aData[uSize + sf_malloc_prehunc+0] = MAGICEND0;
pTmp -> aData[uSize + sf_malloc_prehunc+1] = MAGICEND1;
pTmp -> aData[uSize + sf_malloc_prehunc+2] = MAGICEND2;
pTmp -> aData[uSize + sf_malloc_prehunc+3] = MAGICEND3;
pTmp -> sFileName = (my_string) sFile;
pTmp -> uLineNum = uLine;
pTmp -> uDataSize = uSize;
pTmp -> pPrev = NULL;
/* Add this remember structure to the linked list */
pthread_mutex_lock(&THR_LOCK_malloc);
if ((pTmp->pNext=pRememberRoot))
{
pRememberRoot -> pPrev = pTmp;
}
pRememberRoot = pTmp;
/* Keep the statistics */
lCurMemory += uSize;
if (lCurMemory > lMaxMemory) {
lMaxMemory = lCurMemory;
}
cNewCount++;
pthread_mutex_unlock(&THR_LOCK_malloc);
/* Set the memory to the aribtrary wierd value */
#ifdef HAVE_purify
if (MyFlags & MY_ZEROFILL)
#endif
bfill(&pTmp -> aData[sf_malloc_prehunc],uSize,
(char) (MyFlags & MY_ZEROFILL ? 0 : ALLOC_VAL));
/* Return a pointer to the real data */
DBUG_PRINT("exit",("ptr: %lx",&(pTmp -> aData[sf_malloc_prehunc])));
if (sf_min_adress > &(pTmp -> aData[sf_malloc_prehunc]))
sf_min_adress = &(pTmp -> aData[sf_malloc_prehunc]);
if (sf_max_adress < &(pTmp -> aData[sf_malloc_prehunc]))
sf_max_adress = &(pTmp -> aData[sf_malloc_prehunc]);
DBUG_RETURN ((gptr) &(pTmp -> aData[sf_malloc_prehunc]));
}
void *_mymalloc(size_t size, const char *filename, uint lineno, myf MyFlags)
{
struct st_irem *irem;
uchar *data;
DBUG_ENTER("_mymalloc");
DBUG_PRINT("enter",("Size: %lu", (ulong) size));
if (!sf_malloc_quick)
(void) _sanity (filename, lineno);
if (size + sf_malloc_cur_memory > sf_malloc_mem_limit)
irem= 0;
else
{
/* Allocate the physical memory */
irem= (struct st_irem *) malloc (ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc +
size + /* size requested */
4 + /* overrun mark */
sf_malloc_endhunc);
}
/* Check if there isn't anymore memory avaiable */
if (!irem)
{
if (MyFlags & MY_FAE)
error_handler_hook=fatal_error_handler_hook;
if (MyFlags & (MY_FAE+MY_WME))
{
char buff[256];
my_errno=errno;
sprintf(buff,"Out of memory at line %d, '%s'", lineno, filename);
my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
sprintf(buff,"needed %lu byte (%luk), memory in use: %lu bytes (%luk)",
(ulong) size, (ulong) (size + 1023L) / 1024L,
(ulong) sf_malloc_max_memory,
(ulong) (sf_malloc_max_memory + 1023L) / 1024L);
my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
}
DBUG_PRINT("error",("Out of memory, in use: %ld at line %d, '%s'",
sf_malloc_max_memory,lineno, filename));
if (MyFlags & MY_FAE)
exit(1);
DBUG_RETURN ((void*) 0);
}
/* Fill up the structure */
data= (((uchar*) irem) + ALIGN_SIZE(sizeof(struct st_irem)) +
sf_malloc_prehunc);
*((uint32*) (data-sizeof(uint32)))= MAGICKEY;
data[size + 0]= MAGICEND0;
data[size + 1]= MAGICEND1;
data[size + 2]= MAGICEND2;
data[size + 3]= MAGICEND3;
irem->filename= (char *) filename;
irem->linenum= lineno;
irem->datasize= size;
irem->prev= NULL;
/* Add this remember structure to the linked list */
pthread_mutex_lock(&THR_LOCK_malloc);
if ((irem->next= sf_malloc_root))
sf_malloc_root->prev= irem;
sf_malloc_root= irem;
/* Keep the statistics */
sf_malloc_cur_memory+= size;
if (sf_malloc_cur_memory > sf_malloc_max_memory)
sf_malloc_max_memory= sf_malloc_cur_memory;
sf_malloc_count++;
pthread_mutex_unlock(&THR_LOCK_malloc);
/* Set the memory to the aribtrary wierd value */
if ((MyFlags & MY_ZEROFILL) || !sf_malloc_quick)
bfill(data, size, (char) (MyFlags & MY_ZEROFILL ? 0 : ALLOC_VAL));
/* Return a pointer to the real data */
DBUG_PRINT("exit",("ptr: %p", data));
if (sf_min_adress > data)
sf_min_adress= data;
if (sf_max_adress < data)
sf_max_adress= data;
DBUG_RETURN((void*) data);
}