← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Brian Aker
  • Date: 2010-04-20 06:46:00 UTC
  • Revision ID: brian@gaz-20100420064600-sxejcvnkj359bhz5
Small fixes, remove malloc usage in share creation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
238
238
  return default_item;
239
239
}
240
240
 
241
 
int parse_table_proto(Session& session,
242
 
                      message::Table &table,
243
 
                      TableShare *share)
 
241
static int inner_parse_table_proto(Session& session,
 
242
                                   message::Table &table,
 
243
                                   TableShare *share)
244
244
{
245
245
  int error= 0;
246
246
 
458
458
  uint32_t null_fields= 0;
459
459
  share->reclength= 0;
460
460
 
461
 
  uint32_t *field_offsets= (uint32_t*)malloc(share->fields * sizeof(uint32_t));
462
 
  uint32_t *field_pack_length=(uint32_t*)malloc(share->fields*sizeof(uint32_t));
 
461
  vector<uint32_t> field_offsets;
 
462
  vector<uint32_t> field_pack_length;
463
463
 
464
 
  assert(field_offsets && field_pack_length); // TODO: fixme
 
464
  field_offsets.resize(share->fields);
 
465
  field_pack_length.resize(share->fields);
465
466
 
466
467
  uint32_t interval_count= 0;
467
468
  uint32_t interval_parts= 0;
568
569
    share->intervals= (TYPELIB *) share->mem_root.alloc_root(interval_count*sizeof(TYPELIB));
569
570
  }
570
571
  else
 
572
  {
571
573
    share->intervals= NULL;
 
574
  }
572
575
 
573
576
  share->fieldnames.type_names= (const char **) share->mem_root.alloc_root((share->fields + 1) * sizeof(char*));
574
577
 
769
772
        if (fo.scale() > DECIMAL_MAX_SCALE)
770
773
        {
771
774
          error= 4;
772
 
          goto err;
 
775
 
 
776
          return error;
773
777
        }
774
778
        decimals= static_cast<uint8_t>(fo.scale());
775
779
      }
830
834
      {
831
835
        my_error(ER_M_BIGGER_THAN_D, MYF(0), pfield.name().c_str());
832
836
        error= 1;
833
 
        goto err;
 
837
 
 
838
        return error;
834
839
      }
835
840
      break;
836
841
    }
919
924
      {
920
925
        my_error(ER_INVALID_DEFAULT, MYF(0), f->field_name);
921
926
        error= 1;
922
 
        goto err;
 
927
 
 
928
        return error;
923
929
      }
924
930
    }
925
931
    else if (f->real_type() == DRIZZLE_TYPE_ENUM &&
929
935
      f->store((int64_t) 1, true);
930
936
    }
931
937
    else
 
938
    {
932
939
      f->reset();
 
940
    }
933
941
 
934
942
    /* hack to undo f->init() */
935
943
    f->table= NULL;
987
995
 
988
996
  share->last_null_bit_pos= null_bit_pos;
989
997
 
990
 
  free(field_offsets);
991
 
  field_offsets= NULL;
992
 
  free(field_pack_length);
993
 
  field_pack_length= NULL;
994
 
 
995
998
  /* Fix key stuff */
996
999
  if (share->key_parts)
997
1000
  {
1007
1010
 
1008
1011
      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
1009
1012
      {
1010
 
        /*
1011
 
          If the UNIQUE key doesn't have NULL columns and is not a part key
1012
 
          declare this as a primary key.
1013
 
        */
1014
 
        primary_key=key;
1015
 
        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
1016
 
        {
1017
 
          uint32_t fieldnr= key_part[i].fieldnr;
1018
 
          if (! fieldnr ||
1019
 
              share->field[fieldnr-1]->null_ptr ||
1020
 
              share->field[fieldnr-1]->key_length() != key_part[i].length)
1021
 
          {
1022
 
            primary_key= MAX_KEY; // Can't be used
1023
 
            break;
1024
 
          }
1025
 
        }
 
1013
        /*
 
1014
          If the UNIQUE key doesn't have NULL columns and is not a part key
 
1015
          declare this as a primary key.
 
1016
        */
 
1017
        primary_key=key;
 
1018
        for (uint32_t i= 0; i < keyinfo->key_parts; i++)
 
1019
        {
 
1020
          uint32_t fieldnr= key_part[i].fieldnr;
 
1021
          if (! fieldnr ||
 
1022
              share->field[fieldnr-1]->null_ptr ||
 
1023
              share->field[fieldnr-1]->key_length() != key_part[i].length)
 
1024
          {
 
1025
            primary_key= MAX_KEY; // Can't be used
 
1026
            break;
 
1027
          }
 
1028
        }
1026
1029
      }
1027
1030
 
1028
1031
      for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
1029
1032
      {
1030
 
        Field *field;
1031
 
        if (! key_part->fieldnr)
1032
 
        {
1033
 
          abort(); // goto err;
1034
 
        }
1035
 
        field= key_part->field= share->field[key_part->fieldnr-1];
1036
 
        key_part->type= field->key_type();
1037
 
        if (field->null_ptr)
1038
 
        {
1039
 
          key_part->null_offset=(uint32_t) ((unsigned char*) field->null_ptr -
1040
 
                                        share->default_values);
1041
 
          key_part->null_bit= field->null_bit;
1042
 
          key_part->store_length+=HA_KEY_NULL_LENGTH;
1043
 
          keyinfo->flags|=HA_NULL_PART_KEY;
1044
 
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
1045
 
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
1046
 
        }
1047
 
        if (field->type() == DRIZZLE_TYPE_BLOB ||
1048
 
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
1049
 
        {
1050
 
          if (field->type() == DRIZZLE_TYPE_BLOB)
1051
 
            key_part->key_part_flag|= HA_BLOB_PART;
1052
 
          else
1053
 
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
1054
 
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
1055
 
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
1056
 
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
1057
 
        }
1058
 
        if (i == 0 && key != primary_key)
1059
 
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
1060
 
                           (keyinfo->key_parts == 1)) ?
1061
 
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
1062
 
        if (i == 0)
1063
 
          field->key_start.set(key);
1064
 
        if (field->key_length() == key_part->length &&
1065
 
            !(field->flags & BLOB_FLAG))
1066
 
        {
1067
 
          enum ha_key_alg algo= share->key_info[key].algorithm;
1068
 
          if (share->db_type()->index_flags(algo) & HA_KEYREAD_ONLY)
1069
 
          {
1070
 
            share->keys_for_keyread.set(key);
1071
 
            field->part_of_key.set(key);
1072
 
            field->part_of_key_not_clustered.set(key);
1073
 
          }
1074
 
          if (share->db_type()->index_flags(algo) & HA_READ_ORDER)
1075
 
            field->part_of_sortkey.set(key);
1076
 
        }
1077
 
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
1078
 
            usable_parts == i)
1079
 
          usable_parts++;                       // For FILESORT
1080
 
        field->flags|= PART_KEY_FLAG;
1081
 
        if (key == primary_key)
1082
 
        {
1083
 
          field->flags|= PRI_KEY_FLAG;
1084
 
          /*
1085
 
            If this field is part of the primary key and all keys contains
1086
 
            the primary key, then we can use any key to find this column
1087
 
          */
1088
 
          if (share->storage_engine->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX))
1089
 
          {
1090
 
            field->part_of_key= share->keys_in_use;
1091
 
            if (field->part_of_sortkey.test(key))
1092
 
              field->part_of_sortkey= share->keys_in_use;
1093
 
          }
1094
 
        }
1095
 
        if (field->key_length() != key_part->length)
1096
 
        {
1097
 
          key_part->key_part_flag|= HA_PART_KEY_SEG;
1098
 
        }
 
1033
        Field *field;
 
1034
        if (! key_part->fieldnr)
 
1035
        {
 
1036
          return ENOMEM;
 
1037
        }
 
1038
        field= key_part->field= share->field[key_part->fieldnr-1];
 
1039
        key_part->type= field->key_type();
 
1040
        if (field->null_ptr)
 
1041
        {
 
1042
          key_part->null_offset=(uint32_t) ((unsigned char*) field->null_ptr - share->default_values);
 
1043
          key_part->null_bit= field->null_bit;
 
1044
          key_part->store_length+=HA_KEY_NULL_LENGTH;
 
1045
          keyinfo->flags|=HA_NULL_PART_KEY;
 
1046
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
 
1047
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
 
1048
        }
 
1049
        if (field->type() == DRIZZLE_TYPE_BLOB ||
 
1050
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
 
1051
        {
 
1052
          if (field->type() == DRIZZLE_TYPE_BLOB)
 
1053
            key_part->key_part_flag|= HA_BLOB_PART;
 
1054
          else
 
1055
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
 
1056
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
 
1057
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
 
1058
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
 
1059
        }
 
1060
        if (i == 0 && key != primary_key)
 
1061
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
 
1062
                            (keyinfo->key_parts == 1)) ?
 
1063
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
 
1064
        if (i == 0)
 
1065
          field->key_start.set(key);
 
1066
        if (field->key_length() == key_part->length &&
 
1067
            !(field->flags & BLOB_FLAG))
 
1068
        {
 
1069
          enum ha_key_alg algo= share->key_info[key].algorithm;
 
1070
          if (share->db_type()->index_flags(algo) & HA_KEYREAD_ONLY)
 
1071
          {
 
1072
            share->keys_for_keyread.set(key);
 
1073
            field->part_of_key.set(key);
 
1074
            field->part_of_key_not_clustered.set(key);
 
1075
          }
 
1076
          if (share->db_type()->index_flags(algo) & HA_READ_ORDER)
 
1077
            field->part_of_sortkey.set(key);
 
1078
        }
 
1079
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
 
1080
            usable_parts == i)
 
1081
          usable_parts++;                       // For FILESORT
 
1082
        field->flags|= PART_KEY_FLAG;
 
1083
        if (key == primary_key)
 
1084
        {
 
1085
          field->flags|= PRI_KEY_FLAG;
 
1086
          /*
 
1087
            If this field is part of the primary key and all keys contains
 
1088
            the primary key, then we can use any key to find this column
 
1089
          */
 
1090
          if (share->storage_engine->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX))
 
1091
          {
 
1092
            field->part_of_key= share->keys_in_use;
 
1093
            if (field->part_of_sortkey.test(key))
 
1094
              field->part_of_sortkey= share->keys_in_use;
 
1095
          }
 
1096
        }
 
1097
        if (field->key_length() != key_part->length)
 
1098
        {
 
1099
          key_part->key_part_flag|= HA_PART_KEY_SEG;
 
1100
        }
1099
1101
      }
1100
1102
      keyinfo->usable_key_parts= usable_parts; // Filesort
1101
1103
 
1102
1104
      set_if_bigger(share->max_key_length,keyinfo->key_length+
1103
 
                    keyinfo->key_parts);
 
1105
                    keyinfo->key_parts);
1104
1106
      share->total_key_length+= keyinfo->key_length;
1105
1107
 
1106
1108
      if (keyinfo->flags & HA_NOSAME)
1107
1109
      {
1108
 
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
 
1110
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
1109
1111
      }
1110
1112
    }
1111
1113
    if (primary_key < MAX_KEY &&
1128
1130
      }
1129
1131
    }
1130
1132
    else
 
1133
    {
1131
1134
      share->primary_key = MAX_KEY; // we do not have a primary key
 
1135
    }
1132
1136
  }
1133
1137
  else
 
1138
  {
1134
1139
    share->primary_key= MAX_KEY;
 
1140
  }
1135
1141
 
1136
1142
  if (share->found_next_number_field)
1137
1143
  {
1144
1150
    {
1145
1151
      /* Wrong field definition */
1146
1152
      error= 4;
1147
 
      goto err;
 
1153
 
 
1154
      return error;
1148
1155
    }
1149
1156
    else
 
1157
    {
1150
1158
      reg_field->flags |= AUTO_INCREMENT_FLAG;
 
1159
    }
1151
1160
  }
1152
1161
 
1153
1162
  if (share->blob_fields)
1158
1167
    /* Store offsets to blob fields to find them fast */
1159
1168
    if (!(share->blob_field= save=
1160
1169
          (uint*) share->mem_root.alloc_root((uint32_t) (share->blob_fields* sizeof(uint32_t)))))
1161
 
      goto err;
 
1170
    {
 
1171
      return error;
 
1172
    }
1162
1173
    for (k= 0, ptr= share->field ; *ptr ; ptr++, k++)
1163
1174
    {
1164
1175
      if ((*ptr)->flags & BLOB_FLAG)
1172
1183
  my_bitmap_map *bitmaps;
1173
1184
 
1174
1185
  if (!(bitmaps= (my_bitmap_map*) share->mem_root.alloc_root(share->column_bitmap_size)))
1175
 
    goto err;
1176
 
  share->all_set.init(bitmaps, share->fields);
1177
 
  share->all_set.setAll();
1178
 
 
1179
 
  return (0);
1180
 
 
1181
 
err:
1182
 
  if (field_offsets)
1183
 
    free(field_offsets);
1184
 
  if (field_pack_length)
1185
 
    free(field_pack_length);
 
1186
  { }
 
1187
  else
 
1188
  {
 
1189
    share->all_set.init(bitmaps, share->fields);
 
1190
    share->all_set.setAll();
 
1191
 
 
1192
    return (0);
 
1193
  }
 
1194
 
 
1195
  return error;
 
1196
}
 
1197
 
 
1198
int parse_table_proto(Session& session,
 
1199
                      message::Table &table,
 
1200
                      TableShare *share)
 
1201
{
 
1202
  int error= inner_parse_table_proto(session, table, share);
 
1203
 
 
1204
  if (not error)
 
1205
    return 0;
1186
1206
 
1187
1207
  share->error= error;
1188
1208
  share->open_errno= errno;
1193
1213
  return error;
1194
1214
}
1195
1215
 
 
1216
 
1196
1217
/*
1197
1218
  Read table definition from a binary / text based .frm cursor
1198
1219
 
1648
1669
  case 7:
1649
1670
  case 1:
1650
1671
    if (db_errno == ENOENT)
 
1672
    {
1651
1673
      my_error(ER_NO_SUCH_TABLE, MYF(0), db.str, table_name.str);
 
1674
    }
1652
1675
    else
1653
1676
    {
1654
1677
      snprintf(buff, sizeof(buff), "%s",normalized_path.str);