Examples with AmbiguousColumnException org.apache.phoenix.schema.AmbiguousColumnException used on opensource projects

Example 6 with AmbiguousColumnException

use of org.apache.phoenix.schema.AmbiguousColumnException in project phoenix by apache.

the class ParseNodeRewriter method visit.

@Override
public ParseNode visit(ColumnParseNode node) throws SQLException {
    // check if we find the name in our alias map.
    if (aliasMap != null && node.getTableName() == null) {
        ParseNode aliasedNode = aliasMap.get(node.getName());
        // If we found something, then try to resolve it unless the two nodes are the same
        if (aliasedNode != null && !node.equals(aliasedNode)) {
            ColumnRef ref;
            try {
                ref = resolver.resolveColumn(node.getSchemaName(), node.getTableName(), node.getName());
            } catch (ColumnNotFoundException e) {
                // Not able to resolve alias as a column name as well, so we use the alias
                return aliasedNode;
            }
            // We have resolved it to a column, so now check if the aliased node can be resolved as the same column
            if (aliasedNode instanceof ColumnParseNode) {
                ColumnParseNode aliasedColumnNode = (ColumnParseNode) aliasedNode;
                ColumnRef aliasedRef = resolver.resolveColumn(aliasedColumnNode.getSchemaName(), aliasedColumnNode.getTableName(), aliasedColumnNode.getName());
                if (aliasedRef.equals(ref)) {
                    return aliasedNode;
                }
            }
            // Otherwise it means we have a conflict
            throw new AmbiguousColumnException(node.getName());
        }
    }
    return node;
}

Example 7 with AmbiguousColumnException

use of org.apache.phoenix.schema.AmbiguousColumnException in project phoenix by apache.

the class ProjectionCompiler method projectAllIndexColumns.

private static void projectAllIndexColumns(StatementContext context, TableRef tableRef, boolean resolveColumn, List<Expression> projectedExpressions, List<ExpressionProjector> projectedColumns, List<? extends PDatum> targetColumns) throws SQLException {
    ColumnResolver resolver = context.getResolver();
    PTable index = tableRef.getTable();
    int projectedOffset = projectedExpressions.size();
    PhoenixConnection conn = context.getConnection();
    PName tenantId = conn.getTenantId();
    String tableName = index.getParentName().getString();
    PTable dataTable = null;
    try {
        dataTable = conn.getTable(new PTableKey(tenantId, tableName));
    } catch (TableNotFoundException e) {
        if (tenantId != null) {
            // Check with null tenantId
            dataTable = conn.getTable(new PTableKey(null, tableName));
        } else {
            throw e;
        }
    }
    int tableOffset = dataTable.getBucketNum() == null ? 0 : 1;
    int minTablePKOffset = getMinPKOffset(dataTable, tenantId);
    int minIndexPKOffset = getMinPKOffset(index, tenantId);
    if (index.getIndexType() != IndexType.LOCAL) {
        if (index.getColumns().size() - minIndexPKOffset != dataTable.getColumns().size() - minTablePKOffset) {
            // We'll end up not using this by the optimizer, so just throw
            String schemaNameStr = dataTable.getSchemaName() == null ? null : dataTable.getSchemaName().getString();
            String tableNameStr = dataTable.getTableName() == null ? null : dataTable.getTableName().getString();
            throw new ColumnNotFoundException(schemaNameStr, tableNameStr, null, WildcardParseNode.INSTANCE.toString());
        }
    }
    for (int i = tableOffset, j = tableOffset; i < dataTable.getColumns().size(); i++) {
        PColumn column = dataTable.getColumns().get(i);
        // Skip tenant ID column (which may not be the first column, but is the first PK column)
        if (SchemaUtil.isPKColumn(column) && j++ < minTablePKOffset) {
            tableOffset++;
            continue;
        }
        PColumn tableColumn = dataTable.getColumns().get(i);
        String indexColName = IndexUtil.getIndexColumnName(tableColumn);
        PColumn indexColumn = null;
        ColumnRef ref = null;
        try {
            indexColumn = index.getColumnForColumnName(indexColName);
            ref = new ColumnRef(tableRef, indexColumn.getPosition());
        } catch (ColumnNotFoundException e) {
            if (index.getIndexType() == IndexType.LOCAL) {
                try {
                    ref = new LocalIndexDataColumnRef(context, indexColName);
                    indexColumn = ref.getColumn();
                } catch (ColumnFamilyNotFoundException c) {
                    throw e;
                }
            } else {
                throw e;
            }
        }
        String colName = tableColumn.getName().getString();
        String tableAlias = tableRef.getTableAlias();
        if (resolveColumn) {
            try {
                if (tableAlias != null) {
                    ref = resolver.resolveColumn(null, tableAlias, indexColName);
                } else {
                    String schemaName = index.getSchemaName().getString();
                    ref = resolver.resolveColumn(schemaName.length() == 0 ? null : schemaName, index.getTableName().getString(), indexColName);
                }
            } catch (AmbiguousColumnException e) {
                if (indexColumn.getFamilyName() != null) {
                    ref = resolver.resolveColumn(tableAlias != null ? tableAlias : index.getTableName().getString(), indexColumn.getFamilyName().getString(), indexColName);
                } else {
                    throw e;
                }
            }
        }
        Expression expression = ref.newColumnExpression();
        expression = coerceIfNecessary(i - tableOffset + projectedOffset, targetColumns, expression);
        // We do not need to check if the column is a viewConstant, because view constants never
        // appear as a column in an index
        projectedExpressions.add(expression);
        boolean isCaseSensitive = !SchemaUtil.normalizeIdentifier(colName).equals(colName);
        ExpressionProjector projector = new ExpressionProjector(colName, tableRef.getTableAlias() == null ? dataTable.getName().getString() : tableRef.getTableAlias(), expression, isCaseSensitive);
        projectedColumns.add(projector);
    }
}

Example 8 with AmbiguousColumnException

use of org.apache.phoenix.schema.AmbiguousColumnException in project phoenix by apache.

the class ProjectionCompiler method projectAllTableColumns.

private static void projectAllTableColumns(StatementContext context, TableRef tableRef, boolean resolveColumn, List<Expression> projectedExpressions, List<ExpressionProjector> projectedColumns, List<? extends PDatum> targetColumns) throws SQLException {
    ColumnResolver resolver = context.getResolver();
    PTable table = tableRef.getTable();
    int projectedOffset = projectedExpressions.size();
    int posOffset = table.getBucketNum() == null ? 0 : 1;
    int minPKOffset = getMinPKOffset(table, context.getConnection().getTenantId());
    for (int i = posOffset, j = posOffset; i < table.getColumns().size(); i++) {
        PColumn column = table.getColumns().get(i);
        // Skip tenant ID column (which may not be the first column, but is the first PK column)
        if (SchemaUtil.isPKColumn(column) && j++ < minPKOffset) {
            posOffset++;
            continue;
        }
        ColumnRef ref = new ColumnRef(tableRef, i);
        String colName = ref.getColumn().getName().getString();
        String tableAlias = tableRef.getTableAlias();
        if (resolveColumn) {
            try {
                if (tableAlias != null) {
                    ref = resolver.resolveColumn(null, tableAlias, colName);
                } else {
                    String schemaName = table.getSchemaName().getString();
                    ref = resolver.resolveColumn(schemaName.length() == 0 ? null : schemaName, table.getTableName().getString(), colName);
                }
            } catch (AmbiguousColumnException e) {
                if (column.getFamilyName() != null) {
                    ref = resolver.resolveColumn(tableAlias != null ? tableAlias : table.getTableName().getString(), column.getFamilyName().getString(), colName);
                } else {
                    throw e;
                }
            }
        }
        Expression expression = ref.newColumnExpression();
        expression = coerceIfNecessary(i - posOffset + projectedOffset, targetColumns, expression);
        ImmutableBytesWritable ptr = context.getTempPtr();
        if (IndexUtil.getViewConstantValue(column, ptr)) {
            expression = LiteralExpression.newConstant(column.getDataType().toObject(ptr), expression.getDataType());
        }
        projectedExpressions.add(expression);
        boolean isCaseSensitive = !SchemaUtil.normalizeIdentifier(colName).equals(colName);
        projectedColumns.add(new ExpressionProjector(colName, tableRef.getTableAlias() == null ? table.getName().getString() : tableRef.getTableAlias(), expression, isCaseSensitive));
    }
}

Example 9 with AmbiguousColumnException

use of org.apache.phoenix.schema.AmbiguousColumnException in project phoenix by apache.

the class PhoenixRuntime method generateColumnInfo.

/**
 * Get list of ColumnInfos that contain Column Name and its associated
 * PDataType for an import. The supplied list of columns can be null -- if it is non-null,
 * it represents a user-supplied list of columns to be imported.
 *
 * @param conn Phoenix connection from which metadata will be read
 * @param tableName Phoenix table name whose columns are to be checked. Can include a schema
 *                  name
 * @param columns user-supplied list of import columns, can be null
 */
public static List<ColumnInfo> generateColumnInfo(Connection conn, String tableName, List<String> columns) throws SQLException {
    PTable table = PhoenixRuntime.getTable(conn, SchemaUtil.normalizeFullTableName(tableName));
    List<ColumnInfo> columnInfoList = Lists.newArrayList();
    Set<String> unresolvedColumnNames = new TreeSet<String>();
    if (columns == null || columns.isEmpty()) {
        // use all columns in the table
        int offset = (table.getBucketNum() == null ? 0 : 1);
        for (int i = offset; i < table.getColumns().size(); i++) {
            PColumn pColumn = table.getColumns().get(i);
            columnInfoList.add(PhoenixRuntime.getColumnInfo(pColumn));
        }
    } else {
        // Leave "null" as indication to skip b/c it doesn't exist
        for (int i = 0; i < columns.size(); i++) {
            String columnName = columns.get(i);
            try {
                ColumnInfo columnInfo = PhoenixRuntime.getColumnInfo(table, columnName);
                columnInfoList.add(columnInfo);
            } catch (ColumnNotFoundException cnfe) {
                unresolvedColumnNames.add(columnName);
            } catch (AmbiguousColumnException ace) {
                unresolvedColumnNames.add(columnName);
            }
        }
    }
    // if there exists columns that cannot be resolved, error out.
    if (unresolvedColumnNames.size() > 0) {
        StringBuilder exceptionMessage = new StringBuilder();
        boolean first = true;
        exceptionMessage.append("Unable to resolve these column names:\n");
        for (String col : unresolvedColumnNames) {
            if (first)
                first = false;
            else
                exceptionMessage.append(",");
            exceptionMessage.append(col);
        }
        exceptionMessage.append("\nAvailable columns with column families:\n");
        first = true;
        for (PColumn pColumn : table.getColumns()) {
            if (first)
                first = false;
            else
                exceptionMessage.append(",");
            exceptionMessage.append(pColumn.toString());
        }
        throw new SQLException(exceptionMessage.toString());
    }
    return columnInfoList;
}