@Override public ParseNode visit(ColumnParseNode node) throws SQLException { ColumnRef dataColRef = getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); PColumn dataCol = dataColRef.getColumn(); TableRef dataTableRef = dataColRef.getTableRef(); ParseNode indexColNode = new ColumnParseNode(tName, '"' + indexColName + '"', node.getAlias()); PDataType indexColType = IndexUtil.getIndexColumnDataType(dataCol); PDataType dataColType = dataColRef.getColumn().getDataType();
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { // If we're resolving aliases and we have an unqualified ColumnParseNode, // 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; }
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { if (multiTable && node.getAlias() != null && node.getTableName() != null && SchemaUtil.normalizeIdentifier(node.getAlias()).equals(node.getName())) { node = NODE_FACTORY.column(TableName.create(node.getSchemaName(), node.getTableName()), node.isCaseSensitive() ? '"' + node.getName() + '"' : node.getName(), node.isCaseSensitive() ? '"' + node.getFullName() + '"' : node.getFullName()); } return super.visit(node); }
@Override public Void visit(ColumnParseNode node) throws SQLException { ColumnRef ref = context.getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); boolean isAggregateColumn = groupBy.getExpressions().indexOf(ref.newColumnExpression(node.isTableNameCaseSensitive(), node.isCaseSensitive())) >= 0; if (hasOnlyAggregateColumns == null) { hasOnlyAggregateColumns = isAggregateColumn; } else { hasOnlyAggregateColumns &= isAggregateColumn; } return null; }
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { if (node.getTableName() == null) return super.visit(node); if (removeAlias) { if (node.getTableName().equals(tableAlias)) { return NODE_FACTORY.column(null, node.getName(), node.getAlias()); } return super.visit(node); } ParseNode aliasedNode = aliasMap.get(node.getFullName()); if (aliasedNode != null) { return aliasedNode; } return node; }
@Override public Void visit(ColumnParseNode node) throws SQLException { // Inner query column definitions should shade those of outer query. try { localResolver.resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); addType(true); return null; } catch (TableNotFoundException e) { } catch (ColumnNotFoundException e) { } catch (ColumnFamilyNotFoundException e) { } outerResolver.resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); addType(false); return null; }
ColumnRef ref = resolver.resolveColumn(this.getSchemaName(), this.getTableName(), this.getName()); PColumn column = ref.getColumn(); if (!SchemaUtil.isPKColumn(column)) { if (isTableNameCaseSensitive()) { buf.append('"'); buf.append(tableName); toSQL(buf);
public ColumnParseNode column(TableName tableName, String columnName, String alias) { return new ColumnParseNode(tableName, columnName, alias); }
@Override public Expression visit(ColumnParseNode node) throws SQLException { ColumnRef ref = resolveColumn(node); TableRef tableRef = ref.getTableRef(); Expression newColumnExpression = ref.newColumnExpression(node.isTableNameCaseSensitive(), node.isCaseSensitive()); if (tableRef.equals(context.getCurrentTable()) && !SchemaUtil.isPKColumn(ref.getColumn())) { byte[] cq = tableRef.getTable().getImmutableStorageScheme() == ImmutableStorageScheme.SINGLE_CELL_ARRAY_WITH_OFFSETS ? QueryConstants.SINGLE_KEYVALUE_COLUMN_QUALIFIER_BYTES : ref.getColumn().getColumnQualifierBytes(); // track the where condition columns. Later we need to ensure the Scan in HRS scans these column CFs context.addWhereConditionColumn(ref.getColumn().getFamilyName().getBytes(), cq); } return newColumnExpression; }
public ColumnParseNode(TableName tableName, String name, String alias) { // Upper case here so our Maps can depend on this (and we don't have to upper case and create a string on every // lookup super(name); this.alias = alias; this.tableName = tableName; fullName = tableName == null ? getName() : tableName.toString() + QueryConstants.NAME_SEPARATOR + getName(); }
@Override protected ColumnRef resolveColumn(ColumnParseNode node) throws SQLException { ColumnRef ref = super.resolveColumn(node); isCaseSensitive = isCaseSensitive && node.isCaseSensitive(); return ref; }
table.getParentTableName().getString()); for (PColumn column : parentTableRef.getTable().getColumns()) { NODE_FACTORY.column(null, '"' + IndexUtil.getIndexColumnName(column) + '"', null).accept(visitor); table.getParentTableName().getString()); for (PColumn column : parentTableRef.getTable().getColumnFamily(familyName).getColumns()) { NODE_FACTORY.column(null, '"' + IndexUtil.getIndexColumnName(column) + '"', null).accept(visitor); NODE_FACTORY.column(TableName.create(null, familyName), '"' + column.getName().getString() + '"', null).accept(visitor);
@Override public Void visit(ColumnParseNode node) throws SQLException { try { ColumnRef resolveColumn = context.getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); if (!SchemaUtil.isPKColumn(resolveColumn.getColumn())) { nonPkColumnRefSet.add(resolveColumn); } } catch (ColumnNotFoundException e) { if (context.getCurrentTable().getTable().getIndexType() == IndexType.LOCAL) { try { localIndexColumnRefSet.add(new LocalIndexDataColumnRef(context, context.getCurrentTable(), node.getName())); } catch (ColumnFamilyNotFoundException c) { throw e; } } else { throw e; } } return null; } }
@Override public Void visit(ColumnParseNode node) throws SQLException { ColumnRef ref = context.getResolver().resolveColumn(node.getSchemaName(), node.getTableName(), node.getName()); boolean isAggregateColumn = groupBy.getExpressions().indexOf(ref.newColumnExpression(node.isTableNameCaseSensitive(), node.isCaseSensitive())) >= 0; if (hasOnlyAggregateColumns == null) { hasOnlyAggregateColumns = isAggregateColumn; } else { hasOnlyAggregateColumns &= isAggregateColumn; } return null; }
ColumnRef ref = resolver.resolveColumn(this.getSchemaName(), this.getTableName(), this.getName()); PColumn column = ref.getColumn(); if (!SchemaUtil.isPKColumn(column)) { if (isTableNameCaseSensitive()) { buf.append('"'); buf.append(tableName); toSQL(buf);
@Override public ParseNode visit(ColumnParseNode node) throws SQLException { if (node.getTableName() == null) return super.visit(node); if (removeAlias) { if (node.getTableName().equals(tableAlias)) { return NODE_FACTORY.column(null, node.getName(), node.getAlias()); } return super.visit(node); } ParseNode aliasedNode = aliasMap.get(node.getFullName()); if (aliasedNode != null) { return aliasedNode; } return node; }
@Test public void testToSQL() { ColumnParseNode columnParseNode = new ColumnParseNode(TableName.create("SCHEMA1", "TABLE1"), "V"); CastParseNode castParseNode = new CastParseNode(columnParseNode, PLong.INSTANCE, null, null, false); StringBuilder stringBuilder = new StringBuilder(); castParseNode.toSQL(null, stringBuilder); assertEquals(" CAST(TABLE1.V AS BIGINT)", stringBuilder.toString()); }
@Override public Expression visit(ColumnParseNode node) throws SQLException { ColumnRef ref = resolveColumn(node); TableRef tableRef = ref.getTableRef(); ImmutableBytesWritable ptr = context.getTempPtr(); PColumn column = ref.getColumn(); // If we have an UPDATABLE view, then we compile those view constants (i.e. columns in equality constraints // in the view) to constants. This allows the optimize to optimize out reference to them in various scenarios. // If the column is matched in a WHERE clause against a constant not equal to it's constant, then the entire // query would become degenerate. if (!resolveViewConstants && IndexUtil.getViewConstantValue(column, ptr)) { return LiteralExpression.newConstant(column.getDataType().toObject(ptr), column.getDataType()); } if (tableRef.equals(context.getCurrentTable()) && !SchemaUtil.isPKColumn(column)) { // project only kv columns addColumn(column); } Expression expression = ref.newColumnExpression(node.isTableNameCaseSensitive(), node.isCaseSensitive()); Expression wrappedExpression = wrapGroupByExpression(expression); // If we're in an aggregate expression // and we're not in the context of an aggregate function // and we didn't just wrap our column reference // then we're mixing aggregate and non aggregate expressions in the same expression. // This catches cases like this: SELECT sum(a_integer) + a_integer FROM atable GROUP BY a_string if (isAggregate && aggregateFunction == null && wrappedExpression == expression) { throwNonAggExpressionInAggException(expression.toString()); } return wrappedExpression; }
@Override public Void visit(ColumnParseNode node) throws SQLException { getDataColumnNames().add(node.getName()); return null; }
@Override protected ColumnRef resolveColumn(ColumnParseNode node) throws SQLException { ColumnRef ref = super.resolveColumn(node); isCaseSensitive = isCaseSensitive && node.isCaseSensitive(); return ref; }