static inline ibool check_constraints(rec_t *rec, table_def_t* table, ulint* offsets) {
int i;
ulint len_sum = 0;
if (debug) {
printf("\nChecking constraints for a row (%s) at %p:", table->name, rec);
ut_print_buf(stdout, rec, 100);
}
// Check every field
for(i = 0; i < table->fields_count; i++) {
// Get field value pointer and field length
ulint len;
byte *field = rec_get_nth_field(rec, offsets, i, &len);
if (debug) printf("\n - field %s(addr = %p, len = %lu):", table->fields[i].name, field, len);
if (len != UNIV_SQL_NULL) {
len_sum += len;
}
else {
if (!rec_offs_comp(offsets)) {
len_sum += rec_get_nth_field_size(rec, i);
}
}
// Skip null fields from type checks and fail if null is not allowed by data limits
if (len == UNIV_SQL_NULL) {
if (table->fields[i].has_limits && !table->fields[i].limits.can_be_null) {
if (debug) printf("data can't be NULL");
return FALSE;
}
continue;
}
// Check limits
if (!table->fields[i].has_limits) continue;
if (!check_field_limits(&(table->fields[i]), field, len)) {
if (debug) printf("LIMITS check failed(field = %p, len = %ld)!\n", field, len);
return FALSE;
}
}
// Why do we need this check?
/*
if (len_sum != rec_offs_data_size(offsets)) {
fprintf(stderr,
"\nInnoDB: Error: record len should be %lu, len %lu\n",
(ulong) len_sum,
(ulong) rec_offs_data_size(offsets));
return FALSE;
}
*/
if (debug) printf("\nRow looks OK!\n");
return TRUE;
}
ibool
rec_validate(
/*=========*/
/* out: TRUE if ok */
rec_t* rec) /* in: physical record */
{
byte* data;
ulint len;
ulint n_fields;
ulint len_sum = 0;
ulint sum = 0;
ulint i;
ut_a(rec);
n_fields = rec_get_n_fields(rec);
if ((n_fields == 0) || (n_fields > REC_MAX_N_FIELDS)) {
fprintf(stderr, "InnoDB: Error: record has %lu fields\n",
n_fields);
return(FALSE);
}
for (i = 0; i < n_fields; i++) {
data = rec_get_nth_field(rec, i, &len);
if (!((len < UNIV_PAGE_SIZE) || (len == UNIV_SQL_NULL))) {
fprintf(stderr,
"InnoDB: Error: record field %lu len %lu\n", i,
len);
return(FALSE);
}
if (len != UNIV_SQL_NULL) {
len_sum += len;
sum += *(data + len -1); /* dereference the
end of the field to
cause a memory trap
if possible */
} else {
len_sum += rec_get_nth_field_size(rec, i);
}
}
if (len_sum != (ulint)(rec_get_end(rec) - rec)) {
fprintf(stderr,
"InnoDB: Error: record len should be %lu, len %lu\n",
len_sum, (ulint)(rec_get_end(rec) - rec));
return(FALSE);
}
rec_dummy = sum; /* This is here only to fool the compiler */
return(TRUE);
}
void
rec_print(
/*======*/
rec_t* rec) /* in: physical record */
{
byte* data;
ulint len;
char* offs;
ulint n;
ulint i;
ut_ad(rec);
if (rec_get_1byte_offs_flag(rec)) {
offs = "TRUE";
} else {
offs = "FALSE";
}
n = rec_get_n_fields(rec);
printf(
"PHYSICAL RECORD: n_fields %lu; 1-byte offs %s; info bits %lu\n",
n, offs, rec_get_info_bits(rec));
for (i = 0; i < n; i++) {
data = rec_get_nth_field(rec, i, &len);
printf(" %lu:", i);
if (len != UNIV_SQL_NULL) {
if (len <= 30) {
ut_print_buf(data, len);
} else {
ut_print_buf(data, 30);
printf("...(truncated)");
}
} else {
printf(" SQL NULL, size %lu ",
rec_get_nth_field_size(rec, i));
}
printf(";");
}
printf("\n");
rec_validate(rec);
}
ibool
row_upd_changes_field_size(
/*=======================*/
/* out: TRUE if the update changes the size of
some field in index */
rec_t* rec, /* in: record in clustered index */
dict_index_t* index, /* in: clustered index */
upd_t* update) /* in: update vector */
{
upd_field_t* upd_field;
dfield_t* new_val;
ulint old_len;
ulint new_len;
ulint n_fields;
ulint i;
ut_ad(index->type & DICT_CLUSTERED);
n_fields = upd_get_n_fields(update);
for (i = 0; i < n_fields; i++) {
upd_field = upd_get_nth_field(update, i);
new_val = &(upd_field->new_val);
new_len = new_val->len;
if (new_len == UNIV_SQL_NULL) {
new_len = dtype_get_sql_null_size(
dict_index_get_nth_type(index, i));
}
old_len = rec_get_nth_field_size(rec, upd_field->field_no);
if (old_len != new_len) {
return(TRUE);
}
if (rec_get_nth_field_extern_bit(rec, upd_field->field_no)) {
return(TRUE);
}
if (upd_field->extern_storage) {
return(TRUE);
}
}
return(FALSE);
}
void
rec_set_nth_field_sql_null(
/*=======================*/
rec_t* rec, /* in: record */
ulint n) /* in: index of the field */
{
ulint offset;
offset = rec_get_field_start_offs(rec, n);
data_write_sql_null(rec + offset, rec_get_nth_field_size(rec, n));
rec_set_nth_field_null_bit(rec, n, TRUE);
}
