protected void initKeysAndTags()

in core/src/main/java/site/ycsb/workloads/TimeSeriesWorkload.java [950:1049]
89 lines of code
18 McCabe index (conditional complexity)

  protected void initKeysAndTags() throws WorkloadException {
    final int keyLength = Integer.parseInt(properties.getProperty(
        CoreWorkload.FIELD_LENGTH_PROPERTY, 
        CoreWorkload.FIELD_LENGTH_PROPERTY_DEFAULT));
    final int tagKeyLength = Integer.parseInt(properties.getProperty(
        TAG_KEY_LENGTH_PROPERTY, TAG_KEY_LENGTH_PROPERTY_DEFAULT));
    final int tagValueLength = Integer.parseInt(properties.getProperty(
        TAG_VALUE_LENGTH_PROPERTY, TAG_VALUE_LENGTH_PROPERTY_DEFAULT));
    
    keyGenerator = new IncrementingPrintableStringGenerator(keyLength);
    tagKeyGenerator = new IncrementingPrintableStringGenerator(tagKeyLength);
    tagValueGenerator = new IncrementingPrintableStringGenerator(tagValueLength);
    
    final int threads = Integer.parseInt(properties.getProperty(Client.THREAD_COUNT_PROPERTY, "1"));
    final String tagCardinalityString = properties.getProperty(
        TAG_CARDINALITY_PROPERTY, 
        TAG_CARDINALITY_PROPERTY_DEFAULT);
    final String[] tagCardinalityParts = tagCardinalityString.split(",");
    int idx = 0;
    totalCardinality = numKeys;
    perKeyCardinality = 1;
    int maxCardinality = 0;
    for (final String card : tagCardinalityParts) {
      try {
        tagCardinality[idx] = Integer.parseInt(card.trim());
      } catch (NumberFormatException nfe) {
        throw new WorkloadException("Unable to parse cardinality: " + 
            card, nfe);
      }
      if (tagCardinality[idx] < 1) {
        throw new WorkloadException("Cardinality must be greater than zero: " + 
            tagCardinality[idx]);
      }
      totalCardinality *= tagCardinality[idx];
      perKeyCardinality *= tagCardinality[idx];
      if (tagCardinality[idx] > maxCardinality) {
        maxCardinality = tagCardinality[idx];
      }
      ++idx;
      if (idx >= tagPairs) {
        // we have more cardinalities than tag keys so bail at this point.
        break;
      }
    }
    if (numKeys < threads) {
      throw new WorkloadException("Field count " + numKeys + " (keys for time "
          + "series workloads) must be greater or equal to the number of "
          + "threads " + threads);
    }
    
    // fill tags without explicit cardinality with 1
    if (idx < tagPairs) {
      tagCardinality[idx++] = 1;
    }
    
    for (int i = 0; i < tagCardinality.length; ++i) {
      if (tagCardinality[i] > 1) {
        firstIncrementableCardinality = i;
        break;
      }
    }
    
    keys = new String[numKeys];
    tagKeys = new String[tagPairs];
    tagValues = new String[maxCardinality];
    for (int i = 0; i < numKeys; ++i) {
      keys[i] = keyGenerator.nextString();
    }

    for (int i = 0; i < tagPairs; ++i) {
      tagKeys[i] = tagKeyGenerator.nextString();
    }
    
    for (int i = 0; i < maxCardinality; i++) {
      tagValues[i] = tagValueGenerator.nextString();
    }
    if (randomizeTimeseriesOrder) {
      Utils.shuffleArray(keys);
      Utils.shuffleArray(tagValues);
    }
    
    maxOffsets = (recordcount / totalCardinality) + 1;
    final int[] keyAndTagCardinality = new int[tagPairs + 1];
    keyAndTagCardinality[0] = numKeys;
    for (int i = 0; i < tagPairs; i++) {
      keyAndTagCardinality[i + 1] = tagCardinality[i];
    }
    
    cumulativeCardinality = new int[keyAndTagCardinality.length];
    for (int i = 0; i < keyAndTagCardinality.length; i++) {
      int cumulation = 1;
      for (int x = i; x <= keyAndTagCardinality.length - 1; x++) {
        cumulation *= keyAndTagCardinality[x];
      }
      if (i > 0) {
        cumulativeCardinality[i - 1] = cumulation;
      }
    }
    cumulativeCardinality[cumulativeCardinality.length - 1] = 1;
  }