How to use

validatePrimaryKeys

method

in

co.cask.cdap.spi.data.table.field.FieldValidator

@Override
public void delete(Collection<Field<?>> keys) throws InvalidFieldException, IOException {
 LOG.trace("Table {}: Delete with keys {}", tableSchema.getTableId(), keys);
 fieldValidator.validatePrimaryKeys(keys, false);
 String sqlQuery = getDeleteQuery(keys);
 try (PreparedStatement statement = connection.prepareStatement(sqlQuery)) {
  int index = 1;
  for (Field<?> key : keys) {
   setField(statement, key, index);
   index++;
  }
  LOG.trace("SQL statement: {}", statement);
  statement.executeUpdate();
 } catch (SQLException e) {
  throw new IOException(String.format("Failed to delete the row from table %s with fields %s",
                    tableSchema.getTableId().getName(), keys), e);
 }
}

Collection<Field<?>> keys, @Nullable Collection<String> columns) throws InvalidFieldException, IOException {
LOG.trace("Table {}: Read with keys {} and columns {}", tableSchema.getTableId(), keys, columns);
fieldValidator.validatePrimaryKeys(keys, false);
String readQuery = getReadQuery(keys, columns, false);
try (PreparedStatement statement = connection.prepareStatement(readQuery);) {

 throw new IllegalArgumentException("Cannot use increment on a primary key field");
fieldValidator.validatePrimaryKeys(keys, false);

@Override
public void deleteAll(Range keyRange) throws InvalidFieldException, IOException {
 LOG.trace("Table {}: DeleteAll with range {}", tableSchema.getTableId(), keyRange);
 fieldValidator.validatePrimaryKeys(keyRange.getBegin(), true);
 fieldValidator.validatePrimaryKeys(keyRange.getEnd(), true);
 String sql = getDeleteAllStatement(keyRange);
 try (PreparedStatement statement = connection.prepareStatement(sql)) {
  int index = 1;
  if (keyRange.getBegin() != null) {
   for (Field<?> key : keyRange.getBegin()) {
    setField(statement, key, index);
    index++;
   }
  }
  if (keyRange.getEnd() != null) {
   for (Field<?> key : keyRange.getEnd()) {
    setField(statement, key, index);
    index++;
   }
  }
  LOG.trace("SQL statement: {}", statement);
  statement.executeUpdate();
 } catch (SQLException e) {
  throw new IOException(String.format("Failed to delete the rows from table %s with range %s",
                    tableSchema.getTableId().getName(), keyRange), e);
 }
}

@Override
public CloseableIterator<StructuredRow> scan(Range keyRange, int limit) throws InvalidFieldException, IOException {
 LOG.trace("Table {}: Scan range {} with limit {}", tableSchema.getTableId(), keyRange, limit);
 fieldValidator.validatePrimaryKeys(keyRange.getBegin(), true);
 fieldValidator.validatePrimaryKeys(keyRange.getEnd(), true);
 String scanQuery = getScanQuery(keyRange, limit);
 // We don't close the statement here because once it is closed, the result set is also closed.
 try {
  PreparedStatement statement = connection.prepareStatement(scanQuery);
  int index = 1;
  if (keyRange.getBegin() != null) {
   for (Field<?> key : keyRange.getBegin()) {
    setField(statement, key, index);
    index++;
   }
  }
  if (keyRange.getEnd() != null) {
   for (Field<?> key : keyRange.getEnd()) {
    setField(statement, key, index);
    index++;
   }
  }
  LOG.trace("SQL statement: {}", statement);
  ResultSet resultSet = statement.executeQuery();
  return new ResultSetIterator(statement, resultSet, tableSchema);
 } catch (SQLException e) {
  throw new IOException(String.format("Failed to scan from table %s with range %s",
                    tableSchema.getTableId().getName(), keyRange), e);
 }
}

LOG.trace("Table {}: CompareAndSwap with keys {}, oldValue {}, newValue {}", tableSchema.getTableId(), keys,
     oldValue, newValue);
fieldValidator.validatePrimaryKeys(keys, false);
fieldValidator.validateField(oldValue);
if (oldValue.getFieldType() != newValue.getFieldType()) {

/**
 * Convert the keys to corresponding byte array. The keys can either be a prefix or complete primary keys depending
 * on the value of allowPrefix. The method will always prepend the table name as a prefix for the row keys.
 *
 * @param keys keys to convert
 * @param allowPrefix true if the keys can be prefix false if the keys have to contain all the primary keys.
 * @return the byte array converted
 * @throws InvalidFieldException if the key are not prefix or complete primary keys
 */
private byte[] convertKeyToBytes(Collection<Field<?>> keys, boolean allowPrefix) throws InvalidFieldException {
 fieldValidator.validatePrimaryKeys(keys, allowPrefix);
 MDSKey.Builder mdsKey = new MDSKey.Builder(keyPrefix);
 for (Field<?> key : keys) {
  addKey(mdsKey, key, schema.getType(key.getName()));
 }
 return mdsKey.build().getKey();
}

validator.validatePrimaryKeys(Arrays.asList(Fields.intField(KEY, 10), Fields.longField(KEY2, 100L),
                      Fields.stringField(KEY3, "s")), false);
validator.validatePrimaryKeys(Arrays.asList(Fields.intField(KEY, 10), Fields.longField(KEY2, 100L)),
                      true);
validator.validatePrimaryKeys(Collections.singletonList(Fields.intField(KEY, 10)), true);
 validator.validatePrimaryKeys(Arrays.asList(Fields.floatField(KEY, 10.0f), Fields.longField(KEY2, 100L),
                       Fields.stringField(KEY3, "s")), false);
 Assert.fail("Expected InvalidFieldException");
 validator.validatePrimaryKeys(Arrays.asList(Fields.intField(KEY, 10), Fields.longField(KEY2, 100L)),
                false);
 Assert.fail("Expected InvalidFieldException");