Returns the values for a specific column from a HTML table.

@param tableBy
the way to identify the table
@param columnNumber
the column number
@return a list with all the values corresponding to the specified column
540666
public List<String> getTableColumn(final By tableBy, final int columnNumber) {
		List<String> result = new ArrayList<String>();
		List<List<String>> table = this.getTableAsList(tableBy);

		for (List<String> line : table) {
			result.add(line.get(columnNumber));
		}
		return result;
	}
1017258
public static Object columnlist(PageContext pc, Object obj) throws PageException {
	if (obj instanceof Query) {
	    Key[] columnNames = ((Query) obj).getColumnNames();

	    boolean upperCase = pc.getCurrentTemplateDialect() == CFMLEngine.DIALECT_CFML;

	    StringBuilder sb = new StringBuilder();
	    for (int i = 0; i < columnNames.length; i++) {
		if (i > 0) sb.append(',');
		sb.append(upperCase ? columnNames[i].getUpperString() : columnNames[i].getString());
	    }
	    return sb.toString();

	}
	return pc.getCollection(obj, KeyConstants._COLUMNLIST);
    }
1345758
public Collection<String> getAllColumnNames(final String tableName) {
        return tables.containsKey(tableName) ? tables.get(tableName).getColumns().keySet() : Collections.<String>emptyList();
    }
534945
@Override
    public Object[] findIdsByColumn(String schemaName, String tableName, String pKeyName, String columnName,
        Object columnValue, Class entityClazz) {
        EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClazz);

        return getColumnsById(schemaName, tableName, columnName,
            ((AbstractAttribute) metadata.getIdAttribute()).getJPAColumnName(), columnValue,
            metadata.getIdAttribute().getBindableJavaType()).toArray();
    }
1072147
public int numOfTableColumns() {
        Element rows = tableRows();
        if (rows == null) {
            return -1;
        }
        Element thCells = rows.findChild(app.newElement(Locator.TAGNAME, "th"));
        Element tdCells = rows.findChild(app.newElement(Locator.TAGNAME, "td"));
        return thCells.get().matchCount() + tdCells.get().matchCount();
    }
820693
function getCellsAtColumn(
    opts: Options,
    // The table
    table: Block,
    columnIndex: number
): List<Block> {
    return table.nodes.map(row => row.nodes.get(columnIndex));
}
543499
public static String[] getColumnNames(DataSource ds, String tableName) {
		List<String> columnNames = new ArrayList<String>();
		Connection conn = null;
		ResultSet rs = null;
		try {
			conn = ds.getConnection();
			final DatabaseMetaData metaData = conn.getMetaData();
			rs = metaData.getColumns(conn.getCatalog(), null, tableName, null);
			while (rs.next()) {
				columnNames.add(rs.getString("COLUMN_NAME"));
			}
			return columnNames.toArray(new String[columnNames.size()]);
		} catch (Exception e) {
			throw new DbRuntimeException("Get columns error!", e);
		} finally {
			DbUtil.close(rs, conn);
		}
	}
60027
public function fetchColumn($colNumber = 0)
    {
        $result = $this->fetch(PDO::FETCH_NUM);
        if ($result === false) {
            return false;
        }
        return $result[$colNumber] ?? false;
    }
106144
public int getNumberOfColumns() {
        List<WebElement> cells;
        String xPath = getXPathBase() + "tr";

        List<WebElement> elements = HtmlElementUtils.locateElements(xPath);

        if (elements.size() > 0 && getDataStartIndex() - 1 < elements.size()) {
            cells = elements.get(getDataStartIndex() - 1).findElements(By.xpath("td"));
            return cells.size();
        }

        return 0;
    }
766231
function columnNum(){
        var count;
        var $headerColumns = $header.find(opts.headerCellSelector);
        if(existingColGroup){
          count = $tableColGroup.find('col').length;
        } else {
          count = 0;
          $headerColumns.each(function () {
            count += parseInt(($(this).attr('colspan') || 1), 10);
          });
        }
        if(count !== lastColumnCount){
          lastColumnCount = count;
          var cells = [], cols = [], psuedo = [], content;
          for(var x = 0; x < count; x++){
            content = $headerColumns.eq(x).text();
            cells.push('<th class="floatThead-col" aria-label="'+content+'"/>');
            cols.push('<col/>');
            psuedo.push(
              $('<fthtd>').css({
                'display': 'table-cell',
                'height': 0,
                'width': 'auto'
              })
            );
          }

          cols = cols.join('');
          cells = cells.join('');

          if(createElements){
            $fthRow.empty();
            $fthRow.append(psuedo);
            $fthCells = $fthRow.find('fthtd');
          }

          $sizerRow.html(cells);
          $sizerCells = $sizerRow.find("th");
          if(!existingColGroup){
            $tableColGroup.html(cols);
          }
          $tableCells = $tableColGroup.find('col');
          $floatColGroup.html(cols);
          $headerCells = $floatColGroup.find("col");

        }
        return count;
      }
912944
public String getValueFromCell(int row, int column) {
        if (row < 1 || column < 1) {
            throw new IllegalArgumentException("Row and column must start from 1");
        }
        List<WebElement> elements = HtmlElementUtils.locateElements(getXPathBase() + "tr");
        List<WebElement> cells = elements.get(row - 1).findElements(By.xpath(".//td"));

        if (cells.size() > 0) {
            return cells.get(column - 1).getText();
        }

        return null;
    }
762904
@Override
    public String getTableRowColumnData(int rowNumber, int columnNumber) throws WidgetException {
        try {
            String[] data = getTableRowDataArray(rowNumber);
            return data[columnNumber - 1];
        } catch (Exception e) {
            throw new WidgetException("Error while getting table row column data at row="
                    + rowNumber + " column=" + columnNumber, generateXPathLocator(), e);
        }
    }
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;
    }
21132
public Object[] findIdsByColumn(String schemaName, String tableName, String pKeyName, String columnName,
            Object columnValue, Class entityClazz)
    {
        // TODO Auto-generated method stub
        return null;
    }
1158913
@Override
    public <E> List<E> getColumnsById(String schemaName, String joinTableName, String joinColumnName,
            String inverseJoinColumnName, Object parentId, Class columnJavaType)
    {
        StringBuffer sqlQuery = new StringBuffer();
        sqlQuery.append("SELECT ").append(inverseJoinColumnName).append(" FROM ")
                .append(getFromClause(schemaName, joinTableName)).append(" WHERE ").append(joinColumnName).append("='")
                .append(parentId).append("'");

        Session s = getSession();

        SQLQuery query = s.createSQLQuery(sqlQuery.toString());

        List<E> foreignKeys = new ArrayList<E>();

        foreignKeys = query.list();

        return foreignKeys;
    }
672769
public boolean containsColumn(String columnName) {
        return columns.stream()
            .map(DbColumn::getName)
            .anyMatch(listColName -> listColName.equals(columnName));
    }
803137
public String getCellValue(int rowNumber, int cellNumber) {
        String result;
        checkRowAndCell(rowNumber, cellNumber);
        Sheet sheet = this.workbook.getSheet(this.sheetName);
        Row row = sheet.getRow(--rowNumber);
        Cell cell = row.getCell(--cellNumber);
        switch (cell.getCellTypeEnum()) {
            case BLANK:
                result = cell.getStringCellValue();
                break;
            case BOOLEAN:
                result = String.valueOf(cell.getBooleanCellValue());
                break;
            case ERROR:
                result = String.valueOf(cell.getErrorCellValue());
                break;
            case FORMULA:
                result = cell.getCellFormula();
                break;
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    result = format.format(cell.getDateCellValue());
                } else {
                    result = String.valueOf(cell.getNumericCellValue());
                }
                break;
            case STRING:
                result = cell.getRichStringCellValue().getString();
                break;
            default:
                result = cell.getStringCellValue();
                break;
        }
        return result;
    }