static char *process_int_arg(char *to, char *end, size_t length, longlong par, char arg_type, uint print_type) { size_t res_length, to_length; char *store_start= to, *store_end; char buff[32]; if ((to_length= (size_t) (end-to)) < 16 || length) store_start= buff; if (arg_type == 'd' || arg_type == 'i') store_end= longlong10_to_str(par, store_start, -10); else if (arg_type == 'u') store_end= longlong10_to_str(par, store_start, 10); else if (arg_type == 'p') { store_start[0]= '0'; store_start[1]= 'x'; store_end= ll2str(par, store_start + 2, 16, 0); } else if (arg_type == 'o') { store_end= ll2str(par, store_start, 8, 0); } else { DBUG_ASSERT(arg_type == 'X' || arg_type =='x'); store_end= ll2str(par, store_start, 16, (arg_type == 'X')); } if ((res_length= (size_t) (store_end - store_start)) > to_length) return to; /* num doesn't fit in output */ /* If %#d syntax was used, we have to pre-zero/pre-space the string */ if (store_start == buff) { length= MY_MIN(length, to_length); if (res_length < length) { size_t diff= (length- res_length); memset(to, (print_type & PREZERO_ARG) ? '0' : ' ', diff); if (arg_type == 'p' && print_type & PREZERO_ARG) { if (diff > 1) to[1]= 'x'; else store_start[0]= 'x'; store_start[1]= '0'; } to+= diff; } memmove(to, store_start, res_length); } to+= res_length; return to; }
int my_time_to_str(const MYSQL_TIME *l_time, char *to, uint digits) { uint day= (l_time->year || l_time->month) ? 0 : l_time->day; uint hour= day * 24 + l_time->hour; char*pos= to; if (digits == AUTO_SEC_PART_DIGITS) digits= l_time->second_part ? TIME_SECOND_PART_DIGITS : 0; DBUG_ASSERT(digits <= TIME_SECOND_PART_DIGITS); if(l_time->neg) *pos++= '-'; if(hour > 99) /* Need more than 2 digits for hours in string representation. */ pos= longlong10_to_str((longlong)hour, pos, 10); else pos= fmt_number(hour, pos, 2); *pos++= ':'; pos= fmt_number(l_time->minute, pos, 2); *pos++= ':'; pos= fmt_number(l_time->second, pos, 2); if (digits) { *pos++= '.'; pos= fmt_number((uint)sec_part_shift(l_time->second_part, digits), pos, digits); } *pos= 0; return (int) (pos-to); }
static void convert_from_long(MYSQL_BIND *r_param, const MYSQL_FIELD *field, longlong val, my_bool is_unsigned) { switch (r_param->buffer_type) { case MYSQL_TYPE_TINY: *(uchar *)r_param->buffer= (uchar)val; *r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX8) : NUMERIC_TRUNCATION(val, INT_MIN8, INT_MAX8); r_param->buffer_length= 1; break; case MYSQL_TYPE_SHORT: case MYSQL_TYPE_YEAR: shortstore(r_param->buffer, (short)val); *r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX16) : NUMERIC_TRUNCATION(val, INT_MIN16, INT_MAX16); r_param->buffer_length= 2; break; case MYSQL_TYPE_LONG: longstore(r_param->buffer, (int32)val); *r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX32) : NUMERIC_TRUNCATION(val, INT_MIN32, INT_MAX32); r_param->buffer_length= 4; break; case MYSQL_TYPE_LONGLONG: *r_param->error= (val < 0 && r_param->is_unsigned != is_unsigned); longlongstore(r_param->buffer, val); r_param->buffer_length= 8; break; case MYSQL_TYPE_DOUBLE: { volatile double dbl; dbl= (is_unsigned) ? ulonglong2double((ulonglong)val) : (double)val; doublestore(r_param->buffer, dbl); *r_param->error= is_unsigned ? (ulonglong )dbl != (ulonglong)val : (longlong)dbl != (longlong)val; r_param->buffer_length= 8; break; } case MYSQL_TYPE_FLOAT: { float fval; fval= is_unsigned ? (float)(ulonglong)(val) : (float)val; float4store(r_param->buffer, fval); *r_param->error= is_unsigned ? (ulonglong)fval != (ulonglong)val : (longlong)fval != val; r_param->buffer_length= 4; } break; default: { char buffer[22]; char *endptr; uint len; endptr= longlong10_to_str(val, buffer, is_unsigned ? 10 : -10); len= (uint)(endptr - buffer); /* check if field flag is zerofill */ convert_from_string(r_param, buffer, len); } break; } }
/** Print a timestamp with an optional fractional part: XXXXX[.YYYYY] @param tm The timestamp value to print. @param OUT to The string pointer to print at. @param dec Precision, in the range 0..6. @return The length of the result string. */ int my_timeval_to_str(const struct timeval *tm, char *to, uint dec) { char *pos= longlong10_to_str((longlong) tm->tv_sec, to, 10); if (dec) { *pos++= '.'; pos= fmt_number((uint) sec_part_shift(tm->tv_usec, dec), pos, dec); } *pos= '\0'; return (int) (pos - to); }
void _mi_print_key(FILE *stream, register HA_KEYSEG *keyseg, const uchar *key, uint length) { int flag; short int s_1; long int l_1; float f_1; double d_1; const uchar *end; const uchar *key_end=key+length; (void) fputs("Key: \"",stream); flag=0; for (; keyseg->type && key < key_end ;keyseg++) { if (flag++) (void) putc('-',stream); end= key+ keyseg->length; if (keyseg->flag & HA_NULL_PART) { /* A NULL value is encoded by a 1-byte flag. Zero means NULL. */ if (! *(key++)) { fprintf(stream,"NULL"); continue; } end++; } switch (keyseg->type) { case HA_KEYTYPE_BINARY: if (!(keyseg->flag & HA_SPACE_PACK) && keyseg->length == 1) { /* packed binary digit */ (void) fprintf(stream,"%d",(uint) *key++); break; } /* fall through */ case HA_KEYTYPE_TEXT: case HA_KEYTYPE_NUM: if (keyseg->flag & HA_SPACE_PACK) { (void) fprintf(stream,"%.*s",(int) *key,key+1); key+= (int) *key+1; } else { (void) fprintf(stream,"%.*s",(int) keyseg->length,key); key=end; } break; case HA_KEYTYPE_INT8: (void) fprintf(stream,"%d",(int) *((signed char*) key)); key=end; break; case HA_KEYTYPE_SHORT_INT: s_1= mi_sint2korr(key); (void) fprintf(stream,"%d",(int) s_1); key=end; break; case HA_KEYTYPE_USHORT_INT: { ushort u_1; u_1= mi_uint2korr(key); (void) fprintf(stream,"%u",(uint) u_1); key=end; break; } case HA_KEYTYPE_LONG_INT: l_1=mi_sint4korr(key); (void) fprintf(stream,"%ld",l_1); key=end; break; case HA_KEYTYPE_ULONG_INT: l_1=mi_uint4korr(key); (void) fprintf(stream,"%lu",(ulong) l_1); key=end; break; case HA_KEYTYPE_INT24: (void) fprintf(stream,"%ld",(long) mi_sint3korr(key)); key=end; break; case HA_KEYTYPE_UINT24: (void) fprintf(stream,"%lu",(ulong) mi_uint3korr(key)); key=end; break; case HA_KEYTYPE_FLOAT: mi_float4get(f_1,key); (void) fprintf(stream,"%g",(double) f_1); key=end; break; case HA_KEYTYPE_DOUBLE: mi_float8get(d_1,key); (void) fprintf(stream,"%g",d_1); key=end; break; #ifdef HAVE_LONG_LONG case HA_KEYTYPE_LONGLONG: { char buff[21]; longlong10_to_str(mi_sint8korr(key),buff,-10); (void) fprintf(stream,"%s",buff); key=end; break; } case HA_KEYTYPE_ULONGLONG: { char buff[21]; longlong10_to_str(mi_sint8korr(key),buff,10); (void) fprintf(stream,"%s",buff); key=end; break; } #endif case HA_KEYTYPE_BIT: { uint i; fputs("0x",stream); for (i=0 ; i < keyseg->length ; i++) fprintf(stream, "%02x", (uint) *key++); key= end; break; } case HA_KEYTYPE_VARTEXT1: /* VARCHAR and TEXT */ case HA_KEYTYPE_VARTEXT2: /* VARCHAR and TEXT */ case HA_KEYTYPE_VARBINARY1: /* VARBINARY and BLOB */ case HA_KEYTYPE_VARBINARY2: /* VARBINARY and BLOB */ { uint tmp_length; get_key_length(tmp_length,key); /* The following command sometimes gives a warning from valgrind. Not yet sure if the bug is in valgrind, glibc or mysqld */ (void) fprintf(stream,"%.*s",(int) tmp_length,key); key+=tmp_length; break; } default: break; /* This never happens */ } } (void) fputs("\"\n",stream); return; } /* print_key */
char *ullstr(longlong value,char *buff) { longlong10_to_str(value,buff,10); return buff; }