nus-yam/ex-repair huggingface dataset:
Program: 7943
Project: 7943
Buggy source:
/** 
 * Helper to convert an increment operation
 * @param increment the table increment
 * @return a corresponding data fabric increment operation
 */
private com.continuuity.data.operation.Increment toOperation(Increment increment){
  com.continuuity.data.operation.Increment operation=new com.continuuity.data.operation.Increment(this.tableName(),increment.getRow(),increment.getColumns(),increment.getValues());
  operation.setMetricName(getMetricName());
  return operation;
}

Fixed version (ground truth):
/** 
 * Helper to convert an increment operation.
 * @param increment the table increment
 * @return a corresponding data fabric increment operation
 */
private com.continuuity.data.operation.Increment toOperation(Increment increment){
  com.continuuity.data.operation.Increment operation=new com.continuuity.data.operation.Increment(this.tableName(),increment.getRow(),increment.getColumns(),increment.getValues());
  operation.setMetricName(getMetricName());
  return operation;
}
Program: 7944
Project: 7944
Buggy source:
/** 
 * open the table in the data fabric, to ensure it exists and is accessible.
 * @throws com.continuuity.api.data.OperationException if something goes wrong
 */
public void open() throws OperationException {
  this.dataFabric.openTable(this.getName());
}

Fixed version (ground truth):
/** 
 * Open the table in the data fabric, to ensure it exists and is accessible.
 * @throws OperationException if something goes wrong
 */
public void open() throws OperationException {
  this.dataFabric.openTable(this.getName());
}
Program: 7945
Project: 7945
Buggy source:
/** 
 * Get Application Id
 * @return application id
 */
public String getApplication(){
  return application;
}

Fixed version (ground truth):
/** 
 * Get Application Id.
 * @return application id
 */
public String getApplication(){
  return application;
}
Program: 7946
Project: 7946
Buggy source:
/** 
 * Returns all binary key fields
 * @return Set of keys
 */
public Set<String> getBinaryFields(){
  return this.binaryFields.keySet();
}

Fixed version (ground truth):
/** 
 * Returns the keys of all binary fields.
 * @return Set of keys
 */
public Set<String> getBinaryFields(){
  return this.binaryFields.keySet();
}
Program: 7947
Project: 7947
Buggy source:
/** 
 * Get Metadata type
 * @return metadata type
 */
public String getType(){
  return this.type;
}

Fixed version (ground truth):
/** 
 * Get Metadata type.
 * @return metadata type
 */
public String getType(){
  return this.type;
}
Program: 7948
Project: 7948
Buggy source:
/** 
 * Get Account id
 * @return id
 */
public String getAccount(){
  return account;
}

Fixed version (ground truth):
/** 
 * Get Account id.
 * @return id
 */
public String getAccount(){
  return account;
}
Program: 7949
Project: 7949
Buggy source:
/** 
 * Returns Field value as a String
 * @param field field key
 * @return value
 */
public String getTextField(String field){
  if (field == null)   throw new IllegalArgumentException("String_Node_Str");
  return this.textFields.get(field);
}

Fixed version (ground truth):
/** 
 * Returns Field value as a String.
 * @param field field key
 * @return value
 */
public String getTextField(String field){
  if (field == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return this.textFields.get(field);
}
Program: 7950
Project: 7950
Buggy source:
/** 
 * Comparison function
 * @param o  Object to be compared
 * @return boolean true if the objects passed is equal, false otherwise
 */
public boolean equals(Object o){
  if (this == o)   return true;
  if (!(o instanceof MetaDataEntry))   return false;
  MetaDataEntry other=(MetaDataEntry)o;
  if (!this.account.equals(other.account))   return false;
  if (this.application == null && other.application != null)   return false;
  if (this.application != null && !this.application.equals(other.application))   return false;
  if (!this.id.equals(other.id))   return false;
  if (!this.type.equals(other.type))   return false;
  if (!this.textFields.equals(other.textFields))   return false;
  if (!this.getBinaryFields().equals(other.getBinaryFields()))   return false;
  for (  String key : this.getBinaryFields())   if (!Arrays.equals(this.getBinaryField(key),other.getBinaryField(key)))   return false;
  return true;
}

Fixed version (ground truth):
/** 
 * Comparison function.
 * @param o Object to be compared
 * @return boolean true if the objects passed is equal, false otherwise
 */
public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (!(o instanceof MetaDataEntry)) {
    return false;
  }
  MetaDataEntry other=(MetaDataEntry)o;
  if (!this.account.equals(other.account)) {
    return false;
  }
  if (this.application == null && other.application != null) {
    return false;
  }
  if (this.application != null && !this.application.equals(other.application)) {
    return false;
  }
  if (!this.id.equals(other.id)) {
    return false;
  }
  if (!this.type.equals(other.type)) {
    return false;
  }
  if (!this.textFields.equals(other.textFields)) {
    return false;
  }
  if (!this.getBinaryFields().equals(other.getBinaryFields())) {
    return false;
  }
  for (  String key : this.getBinaryFields()) {
    if (!Arrays.equals(this.getBinaryField(key),other.getBinaryField(key))) {
      return false;
    }
  }
  return true;
}
Program: 7951
Project: 7951
Buggy source:
/** 
 * Adds a field to the metadata
 * @param field field name
 * @param value field value
 */
public void addField(String field,byte[] value){
  if (field == null)   throw new IllegalArgumentException("String_Node_Str");
  if (field.isEmpty())   throw new IllegalArgumentException("String_Node_Str");
  if (value == null)   throw new IllegalArgumentException("String_Node_Str");
  this.binaryFields.put(field,value);
}

Fixed version (ground truth):
/** 
 * Adds a binary field to the metadata.
 * @param field field name
 * @param value field value
 */
public void addField(String field,byte[] value){
  if (field == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (field.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (value == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.binaryFields.put(field,value);
}
Program: 7952
Project: 7952
Buggy source:
/** 
 * Get Metadata id
 * @return metadata id
 */
public String getId(){
  return this.id;
}

Fixed version (ground truth):
/** 
 * Get Metadata id.
 * @return metadata id
 */
public String getId(){
  return this.id;
}
Program: 7953
Project: 7953
Buggy source:
/** 
 * Returns binary field value
 * @param field field key
 * @return value
 */
public byte[] getBinaryField(String field){
  if (field == null)   throw new IllegalArgumentException("String_Node_Str");
  return this.binaryFields.get(field);
}

Fixed version (ground truth):
/** 
 * Returns binary field value.
 * @param field field key
 * @return value
 */
public byte[] getBinaryField(String field){
  if (field == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  return this.binaryFields.get(field);
}
Program: 7954
Project: 7954
Buggy source:
/** 
 * Returns all text key fields
 * @return Set of keys
 */
public Set<String> getTextFields(){
  return this.textFields.keySet();
}

Fixed version (ground truth):
/** 
 * Returns the keys of all text fields.
 * @return Set of keys
 */
public Set<String> getTextFields(){
  return this.textFields.keySet();
}
Program: 7955
Project: 7955
Buggy source:
/** 
 * Constructor
 * @param account account id related to the meta data entry
 * @param application application id related to the meta data entry
 * @param type Type Meta data type
 * @param id Meta data id
 */
public MetaDataEntry(String account,String application,String type,String id){
  if (account == null)   throw new IllegalArgumentException("String_Node_Str");
  if (account.isEmpty())   throw new IllegalArgumentException("String_Node_Str");
  if (id == null)   throw new IllegalArgumentException("String_Node_Str");
  if (id.isEmpty())   throw new IllegalArgumentException("String_Node_Str");
  if (application != null && application.isEmpty())   throw new IllegalArgumentException("String_Node_Str");
  if (type == null)   throw new IllegalArgumentException("String_Node_Str");
  if (type.isEmpty())   throw new IllegalArgumentException("String_Node_Str");
  this.account=account;
  this.application=application;
  this.id=id;
  this.type=type;
  this.textFields=Maps.newTreeMap();
  this.binaryFields=Maps.newTreeMap();
}

Fixed version (ground truth):
/** 
 * @param account     account id related to the meta data entry
 * @param application application id related to the meta data entry
 * @param type        Type Meta data type
 * @param id          Meta data id
 */
public MetaDataEntry(String account,String application,String type,String id){
  if (account == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (account.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (id == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (id.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (application != null && application.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (type == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (type.isEmpty()) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.account=account;
  this.application=application;
  this.id=id;
  this.type=type;
  this.textFields=Maps.newTreeMap();
  this.binaryFields=Maps.newTreeMap();
}
Program: 7956
Project: 7956
Buggy source:
/** 
 * Serialize a meta data entry
 * @param meta the meta data to be serialized
 * @return the serialized meta data as a byte array
 * @throws MetaDataException if serialization fails
 */
public byte[] serialize(MetaDataEntry meta) throws MetaDataException {
  ByteArrayOutputStream outStream=new ByteArrayOutputStream();
  output.setOutputStream(outStream);
  try {
    kryo.writeObject(output,meta);
    output.flush();
    return outStream.toByteArray();
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
    throw new MetaDataException("String_Node_Str",e);
  }
}

Fixed version (ground truth):
/** 
 * Serialize a meta data entry.
 * @param meta the meta data to be serialized
 * @return the serialized meta data as a byte array
 * @throws MetaDataException if serialization fails
 */
public byte[] serialize(MetaDataEntry meta) throws MetaDataException {
  ByteArrayOutputStream outStream=new ByteArrayOutputStream();
  output.setOutputStream(outStream);
  try {
    kryo.writeObject(output,meta);
    output.flush();
    return outStream.toByteArray();
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
    throw new MetaDataException("String_Node_Str",e);
  }
}
Program: 7957
Project: 7957
Buggy source:
/** 
 * Deserialize an meta data entry
 * @param bytes the serialized representation of the meta data
 * @return the deserialized meta data
 * @throws MetaDataException if deserialization fails
 */
public MetaDataEntry deserialize(byte[] bytes) throws MetaDataException {
  ByteArrayInputStream inputStream=new ByteArrayInputStream(bytes);
  input.setInputStream(inputStream);
  try {
    return kryo.readObject(input,MetaData.class);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
    throw new MetaDataException("String_Node_Str",e);
  }
}

Fixed version (ground truth):
/** 
 * Deserialize an meta data entry.
 * @param bytes the serialized representation of the meta data
 * @return the deserialized meta data
 * @throws MetaDataException if deserialization fails
 */
public MetaDataEntry deserialize(byte[] bytes) throws MetaDataException {
  ByteArrayInputStream inputStream=new ByteArrayInputStream(bytes);
  input.setInputStream(inputStream);
  try {
    return kryo.readObject(input,MetaData.class);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str",e);
    throw new MetaDataException("String_Node_Str",e);
  }
}
Program: 7958
Project: 7958
Buggy source:
private byte[][] generateDeleteVals(int length){
  byte[][] values=new byte[length][];
  for (int i=0; i < values.length; i++)   values[i]=NULL_VAL;
  return values;
}

Fixed version (ground truth):
private byte[][] generateDeleteVals(int length){
  byte[][] values=new byte[length][];
  for (int i=0; i < values.length; i++) {
    values[i]=NULL_VAL;
  }
  return values;
}
Program: 7960
Project: 7960
Buggy source:
@Override public OperationResult<ImmutablePair<byte[],Long>> getWithVersion(byte[] row,byte[] column,ReadPointer readPointer) throws OperationException {
  PreparedStatement ps=null;
  try {
    ps=this.connection.prepareStatement("String_Node_Str" + "String_Node_Str" + this.quotedTableName + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
    ps.setBytes(1,row);
    ps.setBytes(2,column);
    ResultSet result=ps.executeQuery();
    ImmutablePair<Long,byte[]> latest=filteredLatest(result,readPointer);
    if (latest == null)     return new OperationResult<ImmutablePair<byte[],Long>>(StatusCode.KEY_NOT_FOUND);
    return new OperationResult<ImmutablePair<byte[],Long>>(new ImmutablePair<byte[],Long>(latest.getSecond(),latest.getFirst()));
  }
 catch (  SQLException e) {
    throw createOperationException(e,"String_Node_Str",ps);
  }
 finally {
    if (ps != null) {
      try {
        ps.close();
      }
 catch (      SQLException e) {
        throw createOperationException(e,"String_Node_Str");
      }
    }
  }
}

Fixed version (ground truth):
@Override public OperationResult<ImmutablePair<byte[],Long>> getWithVersion(byte[] row,byte[] column,ReadPointer readPointer) throws OperationException {
  PreparedStatement ps=null;
  try {
    ps=this.connection.prepareStatement("String_Node_Str" + "String_Node_Str" + this.quotedTableName + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
    ps.setBytes(1,row);
    ps.setBytes(2,column);
    ResultSet result=ps.executeQuery();
    ImmutablePair<Long,byte[]> latest=filteredLatest(result,readPointer);
    if (latest == null) {
      return new OperationResult<ImmutablePair<byte[],Long>>(StatusCode.KEY_NOT_FOUND);
    }
    return new OperationResult<ImmutablePair<byte[],Long>>(new ImmutablePair<byte[],Long>(latest.getSecond(),latest.getFirst()));
  }
 catch (  SQLException e) {
    throw createOperationException(e,"String_Node_Str",ps);
  }
 finally {
    if (ps != null) {
      try {
        ps.close();
      }
 catch (      SQLException e) {
        throw createOperationException(e,"String_Node_Str");
      }
    }
  }
}
Program: 7963
Project: 7963
Buggy source:
/** 
 * Result has (column, version, kvtype, id, value)
 * @throws SQLException
 */
private Map<byte[],byte[]> filteredLatestColumns(ResultSet result,ReadPointer readPointer,int limit) throws SQLException {
  if (limit <= 0)   limit=Integer.MAX_VALUE;
  Map<byte[],byte[]> map=new TreeMap<byte[],byte[]>(Bytes.BYTES_COMPARATOR);
  if (result == null)   return map;
  byte[] curCol=new byte[0];
  byte[] lastCol=new byte[0];
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(2);
    if (!readPointer.isVisible(curVersion))     continue;
    byte[] column=result.getBytes(1);
    if (Bytes.equals(lastCol,column)) {
      continue;
    }
    if (!Bytes.equals(curCol,column)) {
      curCol=column;
      lastDelete=-1;
      undeleted=-1;
    }
    Type type=Type.from(result.getInt(3));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion)       continue;
 else {
        lastCol=column;
        continue;
      }
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete)     continue;
    lastCol=column;
    map.put(column,result.getBytes(5));
    if (map.size() >= limit)     break;
  }
  return map;
}

Fixed version (ground truth):
/** 
 * Result has (column, version, kvtype, id, value).
 * @throws SQLException
 */
private Map<byte[],byte[]> filteredLatestColumns(ResultSet result,ReadPointer readPointer,int limit) throws SQLException {
  if (limit <= 0) {
    limit=Integer.MAX_VALUE;
  }
  Map<byte[],byte[]> map=new TreeMap<byte[],byte[]>(Bytes.BYTES_COMPARATOR);
  if (result == null) {
    return map;
  }
  byte[] curCol=new byte[0];
  byte[] lastCol=new byte[0];
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(2);
    if (!readPointer.isVisible(curVersion)) {
      continue;
    }
    byte[] column=result.getBytes(1);
    if (Bytes.equals(lastCol,column)) {
      continue;
    }
    if (!Bytes.equals(curCol,column)) {
      curCol=column;
      lastDelete=-1;
      undeleted=-1;
    }
    Type type=Type.from(result.getInt(3));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion) {
        continue;
      }
 else {
        lastCol=column;
        continue;
      }
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete) {
      continue;
    }
    lastCol=column;
    map.put(column,result.getBytes(5));
    if (map.size() >= limit) {
      break;
    }
  }
  return map;
}
Program: 7964
Project: 7964
Buggy source:
/** 
 * Result has (version, kvtype, id, value)
 * @throws SQLException
 */
private ImmutablePair<Long,byte[]> filteredLatest(ResultSet result,ReadPointer readPointer) throws SQLException {
  if (result == null)   return null;
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(1);
    if (!readPointer.isVisible(curVersion))     continue;
    Type type=Type.from(result.getInt(2));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion)       continue;
 else       break;
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete)     continue;
    return new ImmutablePair<Long,byte[]>(curVersion,result.getBytes(4));
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Result has (version, kvtype, id, value).
 * @throws SQLException
 */
private ImmutablePair<Long,byte[]> filteredLatest(ResultSet result,ReadPointer readPointer) throws SQLException {
  if (result == null) {
    return null;
  }
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(1);
    if (!readPointer.isVisible(curVersion)) {
      continue;
    }
    Type type=Type.from(result.getInt(2));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion) {
        continue;
      }
 else {
        break;
      }
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete) {
      continue;
    }
    return new ImmutablePair<Long,byte[]>(curVersion,result.getBytes(4));
  }
  return null;
}
Program: 7965
Project: 7965
Buggy source:
/** 
 * Result has (version, kvtype, id, value)
 * @throws SQLException
 */
private ImmutablePair<Long,byte[]> latest(ResultSet result) throws SQLException {
  if (result == null)   return null;
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(1);
    Type type=Type.from(result.getInt(2));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion)       continue;
 else       break;
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete)     continue;
    return new ImmutablePair<Long,byte[]>(curVersion,result.getBytes(4));
  }
  return null;
}

Fixed version (ground truth):
/** 
 * Result has (version, kvtype, id, value).
 * @throws SQLException
 */
private ImmutablePair<Long,byte[]> latest(ResultSet result) throws SQLException {
  if (result == null) {
    return null;
  }
  long lastDelete=-1;
  long undeleted=-1;
  while (result.next()) {
    long curVersion=result.getLong(1);
    Type type=Type.from(result.getInt(2));
    if (type.isUndeleteAll()) {
      undeleted=curVersion;
      continue;
    }
    if (type.isDeleteAll()) {
      if (undeleted == curVersion) {
        continue;
      }
 else {
        break;
      }
    }
    if (type.isDelete()) {
      lastDelete=curVersion;
      continue;
    }
    if (curVersion == lastDelete) {
      continue;
    }
    return new ImmutablePair<Long,byte[]>(curVersion,result.getBytes(4));
  }
  return null;
}
Program: 7968
Project: 7968
Buggy source:
@Override public OrderedVersionedColumnarTable openTable(byte[] tableName) throws OperationException {
  HyperSQLOVCTable table=new HyperSQLOVCTable(Bytes.toString(tableName),this.connection);
  if (table.openTable())   return table;
 else   return null;
}

Fixed version (ground truth):
@Override public OrderedVersionedColumnarTable openTable(byte[] tableName) throws OperationException {
  HyperSQLOVCTable table=new HyperSQLOVCTable(Bytes.toString(tableName),this.connection);
  if (table.openTable()) {
    return table;
  }
 else {
    return null;
  }
}
Program: 7969
Project: 7969
Buggy source:
@Inject public HyperSQLOVCTableHandle(@Named("String_Node_Str") String hyperSqlJDBCString) throws SQLException {
  this.hyperSqlJDBCString=hyperSqlJDBCString;
  this.connection=DriverManager.getConnection(this.hyperSqlJDBCString);
}

Fixed version (ground truth):
@Inject public HyperSQLOVCTableHandle(@Named("String_Node_Str") String hyperSqlJDBCString) throws SQLException {
  this.connection=DriverManager.getConnection(hyperSqlJDBCString);
}
Program: 7970
Project: 7970
Buggy source:
/** 
 * clears the listed scopes (user data, tables, meta data, queues, streams, or all).
 * @param id explicit unique id of this operation
 * @param whatToClear list of scopes to clear
 */
public ClearFabric(long id,List<ToClear> whatToClear){
  super(id);
  setToClear(whatToClear);
}

Fixed version (ground truth):
/** 
 * Clears the listed scopes (user data, tables, meta data, queues, streams, or all).
 * @param id explicit unique id of this operation
 * @param whatToClear list of scopes to clear
 */
public ClearFabric(long id,List<ToClear> whatToClear){
  super(id);
  setToClear(whatToClear);
}
Program: 7971
Project: 7971
Buggy source:
public String toString(){
  return Objects.toStringHelper(this).add("String_Node_Str",Boolean.toString(clearData)).add("String_Node_Str",Boolean.toString(clearMeta)).add("String_Node_Str",Boolean.toString(clearQueues)).add("String_Node_Str",Boolean.toString(clearStreams)).toString();
}

Fixed version (ground truth):
@Override public String toString(){
  return Objects.toStringHelper(this).add("String_Node_Str",Boolean.toString(clearData)).add("String_Node_Str",Boolean.toString(clearMeta)).add("String_Node_Str",Boolean.toString(clearQueues)).add("String_Node_Str",Boolean.toString(clearStreams)).toString();
}
Program: 7972
Project: 7972
Buggy source:
@Override public int getSize(){
  if (newValue == null || newValue.length == 0)   return 0;
  int diff=newValue.length - (expectedValue == null ? 0 : expectedValue.length);
  if (diff < 0)   return 0;
  return diff;
}

Fixed version (ground truth):
@Override public int getSize(){
  if (newValue == null || newValue.length == 0) {
    return 0;
  }
  int diff=newValue.length - (expectedValue == null ? 0 : expectedValue.length);
  if (diff < 0) {
    return 0;
  }
  return diff;
}
Program: 7973
Project: 7973
Buggy source:
/** 
 * Checks the specified columns and amounts arguments for validity.
 * @param columns the columns to increment
 * @param amounts the amounts to increment, in the same order as the columns
 * @throws IllegalArgumentException if no columns specified, no amountsspecified, or number of columns does not match number of amounts.
 */
public static void checkColumnArgs(final Object[] columns,final long[] amounts){
  if (columns == null || columns.length == 0)   throw new IllegalArgumentException("String_Node_Str");
  if (amounts == null || amounts.length == 0)   throw new IllegalArgumentException("String_Node_Str");
  if (columns.length != amounts.length)   throw new IllegalArgumentException("String_Node_Str" + columns.length + "String_Node_Str"+ amounts.length+ "String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Checks the specified columns and amounts arguments for validity.
 * @param columns the columns to increment
 * @param amounts the amounts to increment, in the same order as the columns
 * @throws IllegalArgumentException if no columns specified, no amountsspecified, or number of columns does not match number of amounts.
 */
public static void checkColumnArgs(final Object[] columns,final long[] amounts){
  if (columns == null || columns.length == 0) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (amounts == null || amounts.length == 0) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (columns.length != amounts.length) {
    throw new IllegalArgumentException("String_Node_Str" + columns.length + "String_Node_Str"+ amounts.length+ "String_Node_Str");
  }
}
Program: 7974
Project: 7974
Buggy source:
@Override public int getSize(){
  if (key == null || columns == null)   return 0;
  int size=key.length;
  for (int i=0; i < columns.length; i++) {
    size+=columns[i].length + 8;
  }
  return size;
}

Fixed version (ground truth):
@Override public int getSize(){
  if (key == null || columns == null) {
    return 0;
  }
  int size=key.length;
  for (int i=0; i < columns.length; i++) {
    size+=columns[i].length + 8;
  }
  return size;
}
Program: 7975
Project: 7975
Buggy source:
public String getTableName(){
  return table;
}

Fixed version (ground truth):
/** 
 * Get the table name.
 * @return the table name
 */
public String getTableName(){
  return table;
}
Program: 7976
Project: 7976
Buggy source:
public String toString(){
  return "String_Node_Str" + table + "String_Node_Str";
}

Fixed version (ground truth):
@Override public String toString(){
  return "String_Node_Str" + table + "String_Node_Str";
}
Program: 7977
Project: 7977
Buggy source:
/** 
 * To open the named table
 * @param id explicit unique id of this operation
 * @param tableName the name of the table to open
 */
public OpenTable(long id,String tableName){
  super(id);
  this.table=tableName;
}

Fixed version (ground truth):
/** 
 * To open the named table.
 * @param id explicit unique id of this operation
 * @param tableName the name of the table to open
 */
public OpenTable(long id,String tableName){
  super(id);
  this.table=tableName;
}
Program: 7978
Project: 7978
Buggy source:
/** 
 * set a name to use for the data metrics - ypically the name of the data set that emitted the operation
 * @param name the name to use
 */
public void setMetricName(String name){
  this.metricName=name;
}

Fixed version (ground truth):
/** 
 * set a name to use for the data metrics - typically the name of the data set that emitted the operation.
 * @param name the name to use
 */
public void setMetricName(String name){
  this.metricName=name;
}
Program: 7979
Project: 7979
Buggy source:
/** 
 * @return a name to use for the data metrics - ypically the name ofthe data set that emitted the operation
 */
public @Nullable String getMetricName(){
  return this.metricName;
}

Fixed version (ground truth):
/** 
 * @return a name to use for the data metrics - ypically the name ofthe data set that emitted the operation
 */
@Nullable public String getMetricName(){
  return this.metricName;
}
Program: 7980
Project: 7980
Buggy source:
/** 
 * Constructor with id - typically used for deserialization
 */
protected Operation(long id){
  this.id=id;
}

Fixed version (ground truth):
/** 
 * Constructor with id - typically used for deserialization.
 */
protected Operation(long id){
  this.id=id;
}
Program: 7981
Project: 7981
Buggy source:
/** 
 * Constructor for operation context
 * @param account  account Id
 */
public OperationContext(String account){
  this(account,null);
}

Fixed version (ground truth):
/** 
 * Constructor for operation context.
 * @param account  account Id
 */
public OperationContext(String account){
  this(account,null);
}
Program: 7982
Project: 7982
Buggy source:
/** 
 * getApplicationId
 * @return String application id
 */
public String getApplication(){
  return this.application;
}

Fixed version (ground truth):
/** 
 * @return String application id
 */
public String getApplication(){
  return this.application;
}
Program: 7983
Project: 7983
Buggy source:
/** 
 * getAccountId
 * @return String account Id
 */
public String getAccount(){
  return account;
}

Fixed version (ground truth):
/** 
 * @return String account Id
 */
public String getAccount(){
  return account;
}
Program: 7984
Project: 7984
Buggy source:
public byte[] getKey(){
  return this.key;
}

Fixed version (ground truth):
/** 
 * @return the row key for the read
 */
public byte[] getKey(){
  return this.key;
}
Program: 7985
Project: 7985
Buggy source:
public String getTable(){
  return this.table;
}

Fixed version (ground truth):
/** 
 * @return the table name
 */
public String getTable(){
  return this.table;
}
Program: 7986
Project: 7986
Buggy source:
public String toString(){
  StringBuilder builder=new StringBuilder();
  char sep='[';
  for (  byte[] column : this.columns) {
    builder.append(sep);
    builder.append(new String(column));
    sep=',';
  }
  builder.append(']');
  String columnsStr=builder.toString();
  return Objects.toStringHelper(this).add("String_Node_Str",new String(this.key)).add("String_Node_Str",columnsStr).toString();
}

Fixed version (ground truth):
@Override public String toString(){
  StringBuilder builder=new StringBuilder();
  char sep='[';
  for (  byte[] column : this.columns) {
    builder.append(sep);
    builder.append(new String(column));
    sep=',';
  }
  builder.append(']');
  String columnsStr=builder.toString();
  return Objects.toStringHelper(this).add("String_Node_Str",new String(this.key)).add("String_Node_Str",columnsStr).toString();
}
Program: 7987
Project: 7987
Buggy source:
public byte[][] getColumns(){
  return this.columns;
}

Fixed version (ground truth):
/** 
 * @return the columns to read
 */
public byte[][] getColumns(){
  return this.columns;
}
Program: 7988
Project: 7988
Buggy source:
public ReportConsoleThread(AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config){
  this.groupMetrics=metrics;
  this.groups=groups;
  this.reportInterval=config.getInt("String_Node_Str",reportInterval);
}

Fixed version (ground truth):
public ReportConsoleThread(AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config){
  super(groups,metrics);
  this.reportInterval=config.getInt("String_Node_Str",reportInterval);
}
Program: 7989
Project: 7989
Buggy source:
public ReportFileAppenderThread(String benchmarkName,AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config){
  this.groupMetrics=metrics;
  this.groups=groups;
  this.reportInterval=config.getInt("String_Node_Str",reportInterval);
  this.fileName=config.get("String_Node_Str");
  int pos=benchmarkName.lastIndexOf("String_Node_Str");
  if (pos != -1) {
    this.benchmarkName=benchmarkName.substring(pos + 1,benchmarkName.length());
  }
 else {
    this.benchmarkName=benchmarkName;
  }
  this.metrics=new HashMap<String,ArrayList<Double>>(groups.length);
  for (  AgentGroup group : groups) {
    this.metrics.put(group.getName(),new ArrayList<Double>());
  }
}

Fixed version (ground truth):
public ReportFileAppenderThread(String benchmarkName,AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config){
  super(groups,metrics);
  this.fileName=config.get("String_Node_Str");
  int pos=benchmarkName.lastIndexOf("String_Node_Str");
  if (pos != -1) {
    this.benchmarkName=benchmarkName.substring(pos + 1,benchmarkName.length());
  }
 else {
    this.benchmarkName=benchmarkName;
  }
  this.metrics=new HashMap<String,ArrayList<Double>>(groups.length);
  for (  AgentGroup group : groups) {
    this.metrics.put(group.getName(),new ArrayList<Double>());
  }
}
Program: 7990
Project: 7990
Buggy source:
@Override public void processGroupMetricsInterval(long unixTime,AgentGroup group,long previousMillis,long millis,Map<String,Long> prevMetrics,Map<String,Long> latestMetrics,boolean interrupt){
  if (prevMetrics != null) {
    for (    Map.Entry<String,Long> singleMetric : prevMetrics.entrySet()) {
      String key=singleMetric.getKey();
      long value=singleMetric.getValue();
      if (!interrupt) {
        Long previousValue=prevMetrics.get(key);
        if (previousValue == null)         previousValue=0L;
        long valueSince=value - previousValue;
        long millisSince=millis - previousMillis;
        metrics.get(group.getName()).add(valueSince * 1000.0 / millisSince);
        String metricValue=String.format("String_Node_Str",valueSince * 1000.0 / millisSince);
        String metric=MensaUtils.buildMetric(OPS_PER_SEC_ONE_MIN,Long.toString(unixTime),metricValue,benchmarkName,group.getName(),Integer.toString(group.getNumAgents()),"String_Node_Str");
        LOG.debug("String_Node_Str",metric);
      }
    }
  }
}

Fixed version (ground truth):
@Override public void processGroupMetricsInterval(long unixTime,AgentGroup group,long previousMillis,long millis,Map<String,Long> prevMetrics,Map<String,Long> latestMetrics,boolean interrupt){
  if (prevMetrics != null) {
    for (    Map.Entry<String,Long> singleMetric : latestMetrics.entrySet()) {
      String key=singleMetric.getKey();
      long value=singleMetric.getValue();
      if (!interrupt) {
        Long previousValue=prevMetrics.get(key);
        if (previousValue == null) {
          previousValue=0L;
        }
        long valueSince=value - previousValue;
        long millisSince=millis - previousMillis;
        metrics.get(group.getName()).add(valueSince * 1000.0 / millisSince);
        String metricValue=String.format("String_Node_Str",valueSince * 1000.0 / millisSince);
        String metric=MensaUtils.buildMetric(OPS_PER_SEC_ONE_MIN,Long.toString(unixTime),metricValue,benchmarkName,group.getName(),Integer.toString(group.getNumAgents()),"String_Node_Str");
        LOG.debug("String_Node_Str",metric);
      }
    }
  }
}
Program: 7991
Project: 7991
Buggy source:
public ReportMensaWriterThread(String benchmarkName,AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config,String extraTags){
  this.groupMetrics=metrics;
  this.groups=groups;
  this.reportInterval=config.getInt("String_Node_Str",reportInterval);
  this.fileName=config.get("String_Node_Str");
  int pos=benchmarkName.lastIndexOf("String_Node_Str");
  if (pos != -1) {
    this.benchmarkName=benchmarkName.substring(pos + 1,benchmarkName.length());
  }
 else {
    this.benchmarkName=benchmarkName;
  }
  String mensa=config.get("String_Node_Str");
  if (mensa != null && mensa.length() != 0) {
    String[] hostPort=mensa.split("String_Node_Str");
    this.mensaHost=hostPort[0];
    this.mensaPort=Integer.valueOf(hostPort[1]);
  }
  mensaTags=config.get("String_Node_Str");
  if (mensaTags != null) {
    mensaTags=mensaTags.replace("String_Node_Str","String_Node_Str");
  }
  if (extraTags != null && extraTags.length() != 0) {
    if (mensaTags != null && mensaTags.length() != 0) {
      mensaTags=mensaTags + "String_Node_Str" + extraTags;
    }
 else {
      mensaTags=extraTags;
    }
  }
  this.metrics=new HashMap<String,ArrayList<Double>>(groups.length);
  for (  AgentGroup group : groups) {
    this.metrics.put(group.getName(),new ArrayList<Double>());
  }
}

Fixed version (ground truth):
public ReportMensaWriterThread(String benchmarkName,AgentGroup[] groups,BenchmarkMetric[] metrics,CConfiguration config,String extraTags){
  super(groups,metrics);
  this.fileName=config.get("String_Node_Str");
  int pos=benchmarkName.lastIndexOf("String_Node_Str");
  if (pos != -1) {
    this.benchmarkName=benchmarkName.substring(pos + 1,benchmarkName.length());
  }
 else {
    this.benchmarkName=benchmarkName;
  }
  String mensa=config.get("String_Node_Str");
  if (mensa != null && mensa.length() != 0) {
    String[] hostPort=mensa.split("String_Node_Str");
    this.mensaHost=hostPort[0];
    this.mensaPort=Integer.valueOf(hostPort[1]);
  }
  mensaTags=config.get("String_Node_Str");
  if (mensaTags != null) {
    mensaTags=mensaTags.replace("String_Node_Str","String_Node_Str");
  }
  if (extraTags != null && extraTags.length() != 0) {
    if (mensaTags != null && mensaTags.length() != 0) {
      mensaTags=mensaTags + "String_Node_Str" + extraTags;
    }
 else {
      mensaTags=extraTags;
    }
  }
  this.metrics=new HashMap<String,ArrayList<Double>>(groups.length);
  for (  AgentGroup group : groups) {
    this.metrics.put(group.getName(),new ArrayList<Double>());
  }
}
Program: 7992
Project: 7992
Buggy source:
@Override public void processGroupMetricsInterval(long unixTime,AgentGroup group,long previousMillis,long millis,Map<String,Long> prevMetrics,Map<String,Long> latestMetrics,boolean interrupt) throws BenchmarkException {
  if (prevMetrics != null) {
    for (    Map.Entry<String,Long> singleMetric : prevMetrics.entrySet()) {
      String key=singleMetric.getKey();
      long value=singleMetric.getValue();
      if (!interrupt) {
        Long previousValue=prevMetrics.get(key);
        if (previousValue == null)         previousValue=0L;
        long valueSince=value - previousValue;
        long millisSince=millis - previousMillis;
        metrics.get(group.getName()).add(valueSince * 1000.0 / millisSince);
        String metricValue=String.format("String_Node_Str",valueSince * 1000.0 / millisSince);
        String metric=MensaUtils.buildMetric(OPS_PER_SEC_ONE_MIN,Long.toString(unixTime),metricValue,benchmarkName,group.getName(),Integer.toString(group.getNumAgents()),mensaTags);
        try {
          MensaUtils.uploadMetric(mensaHost,mensaPort,metric);
          LOG.debug("String_Node_Str",metric,mensaHost,mensaPort);
        }
 catch (        IOException e) {
          throw new BenchmarkException("String_Node_Str" + metric + "String_Node_Str"+ mensaHost+ "String_Node_Str"+ mensaPort+ "String_Node_Str",e);
        }
      }
    }
  }
}

Fixed version (ground truth):
@Override public void processGroupMetricsInterval(long unixTime,AgentGroup group,long previousMillis,long millis,Map<String,Long> prevMetrics,Map<String,Long> latestMetrics,boolean interrupt) throws BenchmarkException {
  if (prevMetrics != null) {
    for (    Map.Entry<String,Long> singleMetric : latestMetrics.entrySet()) {
      String metricName=singleMetric.getKey();
      long latestValue=singleMetric.getValue();
      if (!interrupt) {
        Long previousValue=prevMetrics.get(metricName);
        if (previousValue == null) {
          previousValue=0L;
        }
        long valueSince=latestValue - previousValue;
        long millisSince=millis - previousMillis;
        metrics.get(group.getName()).add(valueSince * 1000.0 / millisSince);
        String metricValue=String.format("String_Node_Str",valueSince * 1000.0 / millisSince);
        String metric=MensaUtils.buildMetric(OPS_PER_SEC_10_SEC,Long.toString(unixTime),metricValue,benchmarkName,group.getName(),Integer.toString(group.getNumAgents()),mensaTags);
        try {
          MensaUtils.uploadMetric(mensaHost,mensaPort,metric);
          LOG.debug("String_Node_Str",metric,mensaHost,mensaPort);
        }
 catch (        IOException e) {
          throw new BenchmarkException("String_Node_Str" + metric + "String_Node_Str"+ mensaHost+ "String_Node_Str"+ mensaPort+ "String_Node_Str",e);
        }
      }
    }
  }
}
Program: 7994
Project: 7994
Buggy source:
public boolean validate(String reportLine){
  String[] split=reportLine.split("String_Node_Str");
  String metric=split[1];
  String ts=split[2];
  double newMetricValueAvg=Double.valueOf(split[3]);
  StringBuilder sb=new StringBuilder();
  for (int i=4; i < split.length; i++) {
    if (!split[i].contains("String_Node_Str")) {
      sb.append(split[i]);
      sb.append("String_Node_Str");
    }
  }
  sb.setLength(sb.length() - 1);
  String tags=sb.toString();
  MetricsResult result=queryTSDB(host,port,startts,endts,metric,tags);
  double oldMetricValueAvg=0;
  if (result != null && result.getMetrics().size() != 0) {
    oldMetricValueAvg=result.getMetric(0).avg(7);
  }
  if (newMetricValueAvg < 0.95 * oldMetricValueAvg) {
    System.out.println("String_Node_Str" + oldMetricValueAvg + "String_Node_Str"+ newMetricValueAvg);
    return false;
  }
 else {
    return true;
  }
}

Fixed version (ground truth):
public boolean validate(String reportLine){
  String[] split=reportLine.split("String_Node_Str");
  String metric=split[1];
  String ts=split[2];
  double newMetricValueAvg=Double.valueOf(split[3]);
  StringBuilder sb=new StringBuilder();
  for (int i=4; i < split.length; i++) {
    if (!split[i].contains("String_Node_Str")) {
      sb.append(split[i]);
      sb.append("String_Node_Str");
    }
  }
  sb.setLength(sb.length() - 1);
  String tags=sb.toString();
  MetricsResult result=queryTSDB(host,port,startts,endts,metric,tags);
  double oldMetricValueAvg=0;
  if (result != null && result.getMetrics().size() != 0 && result.getMetric(0).getNumDataPoints() >= 7) {
    oldMetricValueAvg=result.getMetric(0).avg(7);
  }
  if (newMetricValueAvg < 0.95 * oldMetricValueAvg) {
    System.out.println("String_Node_Str" + oldMetricValueAvg + "String_Node_Str"+ newMetricValueAvg);
    return false;
  }
 else {
    return true;
  }
}
Program: 7995
Project: 7995
Buggy source:
/** 
 * Executes a   {@link com.continuuity.data.operation.Increment} operation. Ifa non-null transaction is passed in, the operation is performed in that client-side transaction. Otherwise it is performed and committed as an anonymous transaction.
 * @param context the operation context
 * @param transaction an existing transaction, or null to perform an anonymoustransaction
 * @param increment the operation
 * @return a result object containing a map of columns to the new, incrementedvalues.
 * @throws OperationException is something goes wrong
 */
public Map<byte[],Long> increment(OperationContext context,@Nullable Transaction transaction,Increment increment) throws OperationException ;

Fixed version (ground truth):
/** 
 * Executes a   {@link com.continuuity.data.operation.Increment} operation.A valid transaction must be passed in, and the operation is performed in that client-side transaction.
 * @param context the operation context
 * @param transaction an existing, valid transaction
 * @param increment the operation
 * @return a result object containing a map of columns to the new, incrementedvalues.
 * @throws OperationException is something goes wrong
 */
public Map<byte[],Long> increment(OperationContext context,Transaction transaction,Increment increment) throws OperationException ;
Program: 7996
Project: 7996
Buggy source:
@Override public Map<byte[],Long> increment(OperationContext context,Transaction transaction,Increment increment) throws OperationException {
  if (transaction == null) {
    return increment(context,increment);
  }
  WriteTransactionResult writeTxReturn=write(context,increment,transaction);
  List<Undo> undos=writeTxReturn.undos;
  if (null != undos && !undos.isEmpty()) {
    addToTransaction(transaction,undos);
  }
  if (writeTxReturn.success) {
    return writeTxReturn.incrementResult;
  }
 else {
    cmetric.meter(METRIC_PREFIX + "String_Node_Str",1);
    abort(context,transaction);
    throw new OmidTransactionException(writeTxReturn.statusCode,writeTxReturn.message);
  }
}

Fixed version (ground truth):
@Override public Map<byte[],Long> increment(OperationContext context,Transaction transaction,Increment increment) throws OperationException {
  if (transaction == null) {
    throw new OmidTransactionException(StatusCode.INVALID_TRANSACTION,"String_Node_Str");
  }
 else {
    oracle.validateTransaction(transaction);
  }
  WriteTransactionResult writeTxReturn=write(context,increment,transaction);
  List<Undo> undos=writeTxReturn.undos;
  if (null != undos && !undos.isEmpty()) {
    addToTransaction(transaction,undos);
  }
  if (writeTxReturn.success) {
    return writeTxReturn.incrementResult;
  }
 else {
    cmetric.meter(METRIC_PREFIX + "String_Node_Str",1);
    abort(context,transaction);
    throw new OmidTransactionException(writeTxReturn.statusCode,writeTxReturn.message);
  }
}
Program: 7997
Project: 7997
Buggy source:
public void abort(OperationContext context,Transaction transaction) throws OperationException, TException {
  MetricsHelper helper=newHelper("String_Node_Str");
  if (Log.isTraceEnabled())   Log.trace("String_Node_Str");
  try {
    TOperationContext tcontext=wrap(context);
    client.commit(tcontext,wrap(transaction));
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    helper.success();
  }
 catch (  TOperationException te) {
    helper.failure();
    throw unwrap(te);
  }
catch (  TException te) {
    helper.failure();
    throw te;
  }
}

Fixed version (ground truth):
public void abort(OperationContext context,Transaction transaction) throws OperationException, TException {
  MetricsHelper helper=newHelper("String_Node_Str");
  if (Log.isTraceEnabled())   Log.trace("String_Node_Str");
  try {
    TOperationContext tcontext=wrap(context);
    client.abort(tcontext,wrap(transaction));
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    helper.success();
  }
 catch (  TOperationException te) {
    helper.failure();
    throw unwrap(te);
  }
catch (  TException te) {
    helper.failure();
    throw te;
  }
}
Program: 7998
Project: 7998
Buggy source:
public Map<byte[],Long> increment(OperationContext context,Increment increment) throws TException, OperationException {
  MetricsHelper helper=newHelper("String_Node_Str",increment.getTable());
  try {
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    TOperationContext tcontext=wrap(context);
    TIncrement tReadColumnRange=wrap(increment);
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    Map<ByteBuffer,Long> tResult=client.increment(tcontext,tReadColumnRange);
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    Map<byte[],Long> result=unwrapLongMap(tResult);
    helper.finish(result.isEmpty() ? NoData : Success);
    return result;
  }
 catch (  TOperationException te) {
    helper.failure();
    throw unwrap(te);
  }
catch (  TException te) {
    helper.failure();
    throw te;
  }
}

Fixed version (ground truth):
public Map<byte[],Long> increment(OperationContext context,Increment increment) throws TException, OperationException {
  MetricsHelper helper=newHelper("String_Node_Str",increment.getTable());
  try {
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    TOperationContext tcontext=wrap(context);
    TIncrement tIncrement=wrap(increment);
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    Map<ByteBuffer,Long> tResult=client.increment(tcontext,tIncrement);
    if (Log.isTraceEnabled())     Log.trace("String_Node_Str");
    Map<byte[],Long> result=unwrapLongMap(tResult);
    helper.finish(result.isEmpty() ? NoData : Success);
    return result;
  }
 catch (  TOperationException te) {
    helper.failure();
    throw unwrap(te);
  }
catch (  TException te) {
    helper.failure();
    throw te;
  }
}
Program: 7999
Project: 7999
Buggy source:
@Override public TTQueueTable getQueueTable(byte[] queueTableName) throws OperationException {
  TTQueueTable queueTable=this.queueTables.get(queueTableName);
  if (queueTable != null)   return queueTable;
  OrderedVersionedColumnarTable table=getTable(queueOVCTable);
  queueTable=new TTQueueTableOnVCTable(table,oracle,conf);
  TTQueueTable existing=this.queueTables.putIfAbsent(queueTableName,queueTable);
  return existing != null ? existing : queueTable;
}

Fixed version (ground truth):
@Override public TTQueueTable getQueueTable(byte[] queueTableName) throws OperationException {
  TTQueueTable queueTable=this.queueTables.get(queueTableName);
  if (queueTable != null)   return queueTable;
  OrderedVersionedColumnarTable table=getTable(queueOVCTable);
  queueTable=new TTQueueTableNewOnVCTable(table,oracle,conf);
  TTQueueTable existing=this.queueTables.putIfAbsent(queueTableName,queueTable);
  return existing != null ? existing : queueTable;
}