~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Brian Aker
  • Date: 2010-10-23 01:39:56 UTC
  • mfrom: (1864.3.22 catalogs)
  • Revision ID: brian@tangent.org-20101023013956-mq0xgbtpzpgwx80z
Merge in a bunch of goto removals (just random).

Show diffs side-by-side

added added

removed removed

Lines of Context:
672
672
  if (!my_b_inited(tempfile) &&
673
673
      open_cached_file(tempfile, drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE,
674
674
                       MYF(MY_WME)))
675
 
    goto err;
 
675
  {
 
676
    return 1;
 
677
  }
676
678
  /* check we won't have more buffpeks than we can possibly keep in memory */
677
679
  if (my_b_tell(buffpek_pointers) + sizeof(buffpek) > (uint64_t)UINT_MAX)
678
 
    goto err;
 
680
  {
 
681
    return 1;
 
682
  }
 
683
 
679
684
  buffpek.file_pos= my_b_tell(tempfile);
680
685
  if ((ha_rows) count > param->max_rows)
681
686
    count=(uint32_t) param->max_rows;
682
687
  buffpek.count=(ha_rows) count;
683
688
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
 
689
  {
684
690
    if (my_b_write(tempfile, (unsigned char*) *sort_keys, (uint32_t) rec_length))
685
 
      goto err;
 
691
    {
 
692
      return 1;
 
693
    }
 
694
  }
 
695
 
686
696
  if (my_b_write(buffpek_pointers, (unsigned char*) &buffpek, sizeof(buffpek)))
687
 
    goto err;
688
 
  return(0);
 
697
  {
 
698
    return 1;
 
699
  }
689
700
 
690
 
err:
691
 
  return(1);
 
701
  return 0;
692
702
} /* write_keys */
693
703
 
694
704
 
1016
1026
int merge_many_buff(SORTPARAM *param, unsigned char *sort_buffer,
1017
1027
                    buffpek *buffpek_inst, uint32_t *maxbuffer, internal::IO_CACHE *t_file)
1018
1028
{
1019
 
  register uint32_t i;
1020
1029
  internal::IO_CACHE t_file2,*from_file,*to_file,*temp;
1021
1030
  buffpek *lastbuff;
1022
1031
 
1023
1032
  if (*maxbuffer < MERGEBUFF2)
1024
 
    return(0);
 
1033
    return 0;
1025
1034
  if (flush_io_cache(t_file) ||
1026
 
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE,
1027
 
                        MYF(MY_WME)))
1028
 
    return(1);
 
1035
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE, MYF(MY_WME)))
 
1036
  {
 
1037
    return 1;
 
1038
  }
1029
1039
 
1030
1040
  from_file= t_file ; to_file= &t_file2;
1031
1041
  while (*maxbuffer >= MERGEBUFF2)
1032
1042
  {
 
1043
    register uint32_t i;
 
1044
 
1033
1045
    if (reinit_io_cache(from_file,internal::READ_CACHE,0L,0,0))
1034
 
      goto cleanup;
 
1046
    {
 
1047
      break;
 
1048
    }
 
1049
 
1035
1050
    if (reinit_io_cache(to_file,internal::WRITE_CACHE,0L,0,0))
1036
 
      goto cleanup;
 
1051
    {
 
1052
      break;
 
1053
    }
 
1054
 
1037
1055
    lastbuff=buffpek_inst;
1038
1056
    for (i=0 ; i <= *maxbuffer-MERGEBUFF*3/2 ; i+=MERGEBUFF)
1039
1057
    {
1040
1058
      if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1041
1059
                        buffpek_inst+i,buffpek_inst+i+MERGEBUFF-1,0))
1042
 
      goto cleanup;
 
1060
      {
 
1061
        goto cleanup;
 
1062
      }
1043
1063
    }
 
1064
 
1044
1065
    if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1045
1066
                      buffpek_inst+i,buffpek_inst+ *maxbuffer,0))
 
1067
    {
1046
1068
      break;
 
1069
    }
 
1070
 
1047
1071
    if (flush_io_cache(to_file))
 
1072
    {
1048
1073
      break;
 
1074
    }
 
1075
 
1049
1076
    temp=from_file; from_file=to_file; to_file=temp;
1050
1077
    setup_io_cache(from_file);
1051
1078
    setup_io_cache(to_file);
1052
1079
    *maxbuffer= (uint32_t) (lastbuff-buffpek_inst)-1;
1053
1080
  }
 
1081
 
1054
1082
cleanup:
1055
1083
  close_cached_file(to_file);                   // This holds old result
1056
1084
  if (to_file == t_file)
1181
1209
    strpos+= (uint32_t) (error= (int) read_to_buffer(from_file, buffpek_inst,
1182
1210
                                                                         rec_length));
1183
1211
    if (error == -1)
1184
 
      goto err;
 
1212
      return -1;
 
1213
 
1185
1214
    buffpek_inst->max_keys= buffpek_inst->mem_count;    // If less data in buffers than expected
1186
1215
    queue.push(buffpek_inst);
1187
1216
  }
1200
1229
    memcpy(param->unique_buff, buffpek_inst->key, rec_length);
1201
1230
    if (my_b_write(to_file, (unsigned char*) buffpek_inst->key, rec_length))
1202
1231
    {
1203
 
      error=1; goto err;
 
1232
      return 1;
1204
1233
    }
1205
1234
    buffpek_inst->key+= rec_length;
1206
1235
    buffpek_inst->mem_count--;
1214
1243
    queue.push(buffpek_inst);
1215
1244
  }
1216
1245
  else
 
1246
  {
1217
1247
    cmp= 0;                                        // Not unique
 
1248
  }
1218
1249
 
1219
1250
  while (queue.size() > 1)
1220
1251
  {
1221
1252
    if (*killed)
1222
1253
    {
1223
 
      error= 1; goto err;
 
1254
      return 1;
1224
1255
    }
1225
1256
    for (;;)
1226
1257
    {
1236
1267
      {
1237
1268
        if (my_b_write(to_file,(unsigned char*) buffpek_inst->key, rec_length))
1238
1269
        {
1239
 
          error=1; goto err;
 
1270
          return 1;
1240
1271
        }
1241
1272
      }
1242
1273
      else
1243
1274
      {
1244
1275
        if (my_b_write(to_file, (unsigned char*) buffpek_inst->key+offset, res_length))
1245
1276
        {
1246
 
          error=1; goto err;
 
1277
          return 1;
1247
1278
        }
1248
1279
      }
1249
1280
      if (!--max_rows)
1263
1294
          break;                        /* One buffer have been removed */
1264
1295
        }
1265
1296
        else if (error == -1)
1266
 
          goto err;
 
1297
        {
 
1298
          return -1;
 
1299
        }
1267
1300
      }
1268
1301
      /* Top element has been replaced */
1269
1302
      queue.pop();
1300
1333
      if (my_b_write(to_file,(unsigned char*) buffpek_inst->key,
1301
1334
                     (rec_length*buffpek_inst->mem_count)))
1302
1335
      {
1303
 
        error= 1; goto err;
 
1336
        return 1;
1304
1337
      }
1305
1338
    }
1306
1339
    else
1313
1346
      {
1314
1347
        if (my_b_write(to_file, (unsigned char *) strpos, res_length))
1315
1348
        {
1316
 
          error=1; goto err;
 
1349
          return 1;
1317
1350
        }
1318
1351
      }
1319
1352
    }
1320
1353
  }
 
1354
 
1321
1355
  while ((error=(int) read_to_buffer(from_file,buffpek_inst, rec_length))
1322
1356
         != -1 && error != 0);
1323
1357
 
1324
1358
end:
1325
1359
  lastbuff->count= min(org_max_rows-max_rows, param->max_rows);
1326
1360
  lastbuff->file_pos= to_start_filepos;
1327
 
err:
1328
 
  return(error);
 
1361
 
 
1362
  return error;
1329
1363
} /* merge_buffers */
1330
1364
 
1331
1365