public DataValue getDataValue()

in phoenix-pherf/src/main/java/org/apache/phoenix/pherf/rules/RulesApplier.java [203:341]
128 lines of code
43 McCabe index (conditional complexity)

    public DataValue getDataValue(Column column) throws Exception {
        DataValue data = null;
        String prefix = "";
        int length = column.getLength();
        int nullChance = column.getNullChance();
        List<DataValue> dataValues = column.getDataValues();

        // Return an empty value if we fall within the configured probability of null
        if ((nullChance != Integer.MIN_VALUE) && (isValueNull(nullChance))) {
            return new DataValue(column.getType(), "");
        }

        if (column.getPrefix() != null) {
            prefix = column.getPrefix();
        }

        if ((prefix.length() >= length) && (length > 0)) {
            LOGGER.warn("You are attempting to generate data with a prefix (" + prefix + ") "
                    + "That is longer than expected overall field length (" + length + "). "
                    + "This will certainly lead to unexpected data values.");
        }

        switch (column.getType()) {
        case VARCHAR:
        case VARBINARY:
        case JSON:
        case BSON:
        case CHAR:
            // Use the specified data values from configs if they exist
            if (DataSequence.SEQUENTIAL.equals(column.getDataSequence())) {
                RuleBasedDataGenerator generator = getRuleBasedDataGeneratorForColumn(column);
                data = generator.getDataValue();
            } else if ((column.getDataValues() != null) && (column.getDataValues().size() > 0)) {
                data = pickDataValueFromList(dataValues);
            } else {
                Preconditions.checkArgument(length > 0, "length needs to be > 0");
                data = getRandomDataValue(column);
            }
            break;
        case VARCHAR_ARRAY:
            //only list datavalues are supported
            String arr = "";
            for (DataValue dv : dataValues) {
                arr += "," + dv.getValue();
            }
            if (arr.startsWith(",")) {
                arr = arr.replaceFirst(",", "");
            }
            data = new DataValue(column.getType(), arr);
            break;
        case DECIMAL:
            if ((column.getDataValues() != null) && (column.getDataValues().size() > 0)) {
                data = pickDataValueFromList(dataValues);
            } else {
                int precision = column.getPrecision();
                double minDbl = column.getMinValue();
                Preconditions.checkArgument((precision > 0) && (precision <= 18),
                        "Precision must be between 0 and 18");
                Preconditions.checkArgument(minDbl >= 0,
                        "minvalue must be set in configuration for decimal");
                Preconditions.checkArgument(column.getMaxValue() > 0,
                        "maxValue must be set in configuration decimal");
                StringBuilder maxValueStr = new StringBuilder();

                for (int i = 0; i < precision; i++) {
                    maxValueStr.append(9);
                }

                double maxDbl =
                        Math.min(column.getMaxValue(), Double.parseDouble(maxValueStr.toString()));
                final double dbl = RandomUtils.nextDouble(minDbl, maxDbl);
                data = new DataValue(column.getType(), String.valueOf(dbl));
            }
            break;
        case TINYINT:
        case INTEGER:
            if ((column.getDataValues() != null) && (column.getDataValues().size() > 0)) {
                data = pickDataValueFromList(dataValues);
            } else if (DataSequence.SEQUENTIAL.equals(column.getDataSequence())) {
                RuleBasedDataGenerator generator = getRuleBasedDataGeneratorForColumn(column);
                data = generator.getDataValue();
            } else {
                int minInt = (int) column.getMinValue();
                int maxInt = (int) column.getMaxValue();
                if (column.getType() == DataTypeMapping.TINYINT) {
                    Preconditions.checkArgument((minInt >= -128) && (minInt <= 128),
                            "min value need to be set in configuration for tinyints " + column.getName());
                    Preconditions.checkArgument((maxInt >= -128) && (maxInt <= 128),
                            "max value need to be set in configuration for tinyints " + column.getName());
                }
                int intVal = ThreadLocalRandom.current().nextInt(minInt, maxInt + 1);
                data = new DataValue(column.getType(), String.valueOf(intVal));
            }
            break;
        case BIGINT:
        case UNSIGNED_LONG:
            if ((column.getDataValues() != null) && (column.getDataValues().size() > 0)) {
                data = pickDataValueFromList(dataValues);
            } else {
                long minLong = column.getMinValue();
                long maxLong = column.getMaxValue();
                if (column.getType() == DataTypeMapping.UNSIGNED_LONG)
                    Preconditions.checkArgument((minLong > 0) && (maxLong > 0),
                            "min and max values need to be set in configuration for unsigned_longs " + column.getName());
                long longVal = RandomUtils.nextLong(minLong, maxLong);
                data = new DataValue(column.getType(), String.valueOf(longVal));
            }
            break;
        case DATE:
        case TIMESTAMP:
            if ((column.getDataValues() != null) && (column.getDataValues().size() > 0)) {
                data = pickDataValueFromList(dataValues);
                // Check if date has right format or not
                data.setValue(checkDatePattern(data.getValue()));
            } else if (DataSequence.SEQUENTIAL.equals(column.getDataSequence())) {
                RuleBasedDataGenerator generator = getRuleBasedDataGeneratorForColumn(column);
                data = generator.getDataValue();
            } else if (column.getUseCurrentDate() != true) {
                int minYear = (int) column.getMinValue();
                int maxYear = (int) column.getMaxValue();
                Preconditions.checkArgument((minYear > 0) && (maxYear > 0),
                        "min and max values need to be set in configuration for date/timestamps " + column.getName());

                String dt = generateRandomDate(minYear, maxYear);
                data = new DataValue(column.getType(), dt);
                data.setMaxValue(String.valueOf(minYear));
                data.setMinValue(String.valueOf(maxYear));
            } else {
                String dt = getCurrentDate();
                data = new DataValue(column.getType(), dt);
            }
            break;
        default:
            break;
        }
        Preconditions.checkArgument(data != null,
                "Data value could not be generated for some reason. Please check configs");
        return data;
    }