<p>getAlterStatus.</p>

@param tableName a {@link java.lang.String} object.
@return a {@link org.apache.hadoop.hbase.util.Pair} object.
@throws java.io.IOException if any.
326484
public Pair<Integer, Integer> getAlterStatus(String tableName) throws IOException {
    return getAlterStatus(TableName.valueOf(tableName));
  }
760854
public EntityConfig getEntityConfigByTableName(String tableName) {
        for (EntityConfig entityConfig : entityConfigs) {
            if (tableName.equalsIgnoreCase(entityConfig.getTableName())) {
                return entityConfig;
            }
        }
        return null;
    }
105795
public String generateSqlDelete(String tableName) {
        try {
            return cacheSQLs.get("DELETE:" + tableName, () -> {
                return MessageFormat.format("DELETE FROM {0} WHERE {1}", tableName,
                        strWherePkClause);
            });
        } catch (ExecutionException e) {
            throw new DaoException(e);
        }
    }
1139807
public static Table getTable(DatabaseMetaData metadata, String tableName) throws Exception {
        return new Table(
            tableName,
            getPrimaryKey(metadata, tableName),
            getForeignKeys(metadata, tableName),
            getExportedKeys(metadata, tableName),
            getColumns(metadata, tableName)
        );
    }
465537
public Object getColumnValue(String columnName) {
		for ( int j = 0; j < columnNames.length; j++ ) {
			if ( columnNames[j].equals( columnName ) ) {
				return columnValues[j];
			}
		}
		return null;
	}
1318426
public int queryObjCountByCondition(String tableName, String condition,Object[] paramArray){
		/*		JdbcTemplate jdbcTemplate = (JdbcTemplate) MicroDbHolder
		.getDbSource(dbName);*/
		//String tableName=changeTableNameCase(otableName);
		JdbcTemplate jdbcTemplate = getMicroJdbcTemplate();
		String sql="";
		sql="select count(1) from " + tableName + " where "+condition;
		logger.debug(sql);
		logger.debug(Arrays.toString(paramArray));
		Integer total=jdbcTemplate.queryForObject(sql,Integer.class,paramArray);
		return total;
	}
233007
private static String getTable(final Map<String, String> properties) {
		String table = properties.get("table");
		if (table == null) {
			throw new IllegalArgumentException("Name of database table is missing for JDBC writer");
		} else {
			return table;
		}
	}
612478
public TableMetadata getTableMetadata(String tableName){
		if(tableName == null) return null;
		
		try {
			tableMetadataStatement.setInt(1, tableName.hashCode());
			ResultSet set = tableMetadataStatement.executeQuery();
			
			return transformToTableMetadata(set);
		} catch (SQLException e) {
			throw new BackendException("Could not get TableMetadata for table '" + tableName + "'", e);
		}
	}
818860
public boolean has(String tableName, String columnName) {
		return has(EXTENSION_NAME, tableName, columnName)
				&& connection.tableExists(getRTreeTableName(tableName,
						columnName));
	}
1013214
@Override
    public long count(final String tableName, final String familyName,
            @Nullable final XPath condition) throws IOException
    {
        logger.debug("TEPHRA Begin count");
        // VERY INEFFICIENT: to be improved!
        final Stream<Record> cur = Stream.create(new HBaseScanIterator(this, tableName,
                familyName, condition, null, getServerFilterFlag()));
        try {
            return cur.count();
        } finally {
            cur.close();
        }
    }
300377
@SuppressWarnings("unchecked")
    public static <T> Set<T> getTableValue(final Table table) {
        final Object value = table.getValue();
        Set<T> idsReturn;
        if (value == null) {
            idsReturn = Collections.emptySet();
        } else if (value instanceof Collection) {
            final Collection<T> ids = (Collection<T>) value;
            idsReturn = ids.stream().filter(Objects::nonNull).collect(Collectors.toSet());
        } else {
            final T id = (T) value;
            idsReturn = Collections.singleton(id);
        }
        return idsReturn;
    }
974200
public TableIdx getTableIdx(final String _tableName,
                                final String... _keys)
    {
        TableIdx ret = null;
        final String key = _tableName + "-" + StringUtils.join(_keys, "-");
        final Optional<TableIdx> val = this.tableidxs.stream().filter(t -> t.getKey().equals(key)).findFirst();
        if (val.isPresent()) {
            ret = val.get();
            ret.setCreated(false);
        } else {
            ret = new TableIdx().setCreated(true).setTable(_tableName).setIdx(this.currentIdx++).setKey(key);
            this.tableidxs.add(ret);
        }
        return ret;
    }
1087462
public String getTable(FilterNode node) {
        if (tableStrategy == null) return table;
        String t = tableStrategy.getTable(table, node);
        return t == null || t.isEmpty() ? table : t;
    }
110365
public TableInfo getTableInfo(String tblName, Transaction tx) {
		// Optimization:
		TableInfo resultTi = tiMap.get(tblName);
		if (resultTi != null)
			return resultTi;

		RecordFile tcatfile = tcatInfo.open(tx, true);
		tcatfile.beforeFirst();
		boolean found = false;
		while (tcatfile.next()) {
			String t = (String) tcatfile.getVal(TCAT_TBLNAME).asJavaVal();
			if (t.equals(tblName)) {
				found = true;
				break;
			}
		}
		tcatfile.close();
		// return null if table is undefined
		if (!found)
			return null;

		RecordFile fcatfile = fcatInfo.open(tx, true);
		fcatfile.beforeFirst();
		Schema sch = new Schema();
		while (fcatfile.next())
			if (((String) fcatfile.getVal(FCAT_TBLNAME).asJavaVal())
					.equals(tblName)) {
				String fldname = (String) fcatfile.getVal(FCAT_FLDNAME)
						.asJavaVal();
				int fldtype = (Integer) fcatfile.getVal(FCAT_TYPE).asJavaVal();
				int fldarg = (Integer) fcatfile.getVal(FCAT_TYPEARG)
						.asJavaVal();
				sch.addField(fldname, Type.newInstance(fldtype, fldarg));
			}
		fcatfile.close();
		// Optimization:
		resultTi = new TableInfo(tblName, sch);
		tiMap.put(tblName, resultTi);
		return resultTi;
	}
218097
public StreamReader getTableData(String name) throws IOException
   {
      InputStream stream = new ByteArrayInputStream(m_tableData.get(name));
      if (m_majorVersion > 5)
      {        
         byte[] header = new byte[24];
         stream.read(header);
         SynchroLogger.log("TABLE HEADER", header);
      }
      return new StreamReader(m_majorVersion, stream);
   }
248517
@Override
    public java.util.concurrent.Future<DeleteTableResult> deleteTableAsync(String tableName) {

        return deleteTableAsync(new DeleteTableRequest().withTableName(tableName));
    }
708531
Result get(final String tableName, final Object rowKey) throws UncheckedIOException {
        return get(tableName, AnyGet.of(rowKey));
    }