private static String guessTableName(Context context, String givenName) { String qualifiedName; if (CatalogUtil.isFQTableName(givenName)) { qualifiedName = givenName; } else { qualifiedName = CatalogUtil.buildFQName(context.queryContext.get(SessionVars.CURRENT_DATABASE), givenName); } return qualifiedName; }
ResultSet res = pstmt.executeQuery(); if (!res.next()) { throw new UndefinedIndexException(CatalogUtil.buildFQName(databaseName, indexName));
private static String getQualifiedName(PlanContext context, String simpleName) { return CatalogUtil.isFQTableName(simpleName) ? simpleName : CatalogUtil.buildFQName(context.getQueryContext().get(SessionVars.CURRENT_DATABASE), simpleName); }
private void resultToIndexDescProtoBuilder(final String qualifier, final IndexDescProto.Builder builder, final ResultSet res) throws SQLException { builder.setIndexName(res.getString("index_name")); builder.setIndexMethod(getIndexMethod(res.getString("index_type").trim())); builder.setIndexPath(res.getString("path")); String[] columnNames, dataTypes, orders, nullOrders; columnNames = res.getString("column_names").trim().split(","); dataTypes = res.getString("data_types").trim().split(","); orders = res.getString("orders").trim().split(","); nullOrders = res.getString("null_orders").trim().split(","); int columnNum = columnNames.length; for (int i = 0; i < columnNum; i++) { SortSpecProto.Builder colSpecBuilder = SortSpecProto.newBuilder(); colSpecBuilder.setColumn(ColumnProto.newBuilder().setName(CatalogUtil.buildFQName(qualifier, columnNames[i])) .setDataType(CatalogUtil.newSimpleDataType(getDataType(dataTypes[i]))).build()); colSpecBuilder.setAscending(orders[i].equals("true")); colSpecBuilder.setNullFirst(nullOrders[i].equals("true")); builder.addKeySortSpecs(colSpecBuilder.build()); } builder.setIsUnique(res.getBoolean("is_unique")); builder.setIsClustered(res.getBoolean("is_clustered")); }
private boolean assertRelationExistence(Context context, String tableName) { String qualifiedName; if (CatalogUtil.isFQTableName(tableName)) { qualifiedName = tableName; } else { qualifiedName = CatalogUtil.buildFQName(context.queryContext.get(SessionVars.CURRENT_DATABASE), tableName); } if (!catalog.existsTable(qualifiedName)) { context.state.addVerification(new UndefinedTableException(qualifiedName)); return false; } return true; }
String tableName = getTableName(conn, tid); builder.setTid(tid); builder.setName(CatalogUtil.buildFQName(databaseName, tableName, resultSet.getString("COLUMN_NAME")));
simpleTableName = tableName; String qualifiedName = CatalogUtil.buildFQName(databaseName, simpleTableName);
@Override protected EvalNode visitField(Context context, FieldEval field, Stack<EvalNode> stack) { // strip the database name String tableName; if (CatalogUtil.isSimpleIdentifier(field.getQualifier())) { tableName = field.getQualifier(); } else { tableName = CatalogUtil.extractSimpleName(field.getQualifier()); } context.append(CatalogUtil.buildFQName(tableName, field.getColumnName())); return field; }
public String getCanonicalName() { if (CatalogUtil.isFQTableName(this.tableDesc.getName())) { String databaseName = CatalogUtil.extractQualifier(this.tableDesc.getName()); return hasAlias() ? CatalogUtil.buildFQName(databaseName, alias) : tableDesc.getName(); } else { return hasAlias() ? alias : tableDesc.getName(); } }
@Override public LogicalNode visitDropTable(PlanContext context, Stack<Expr> stack, DropTable dropTable) { DropTableNode dropTableNode = context.queryBlock.getNodeFromExpr(dropTable); String qualified; if (CatalogUtil.isFQTableName(dropTable.getTableName())) { qualified = dropTable.getTableName(); } else { qualified = CatalogUtil.buildFQName( context.queryContext.get(SessionVars.CURRENT_DATABASE), dropTable.getTableName()); } dropTableNode.init(qualified, dropTable.isIfExists(), dropTable.isPurge()); return dropTableNode; }
public void init(TableDesc desc, String alias) { this.tableDesc = desc; this.alias = alias; if (!CatalogUtil.isFQTableName(this.tableDesc.getName())) { throw new IllegalArgumentException("the name in TableDesc must be qualified, but it is \"" + desc.getName() + "\""); } String databaseName = CatalogUtil.extractQualifier(this.tableDesc.getName()); String qualifiedAlias = CatalogUtil.buildFQName(databaseName, alias); this.setInSchema(tableDesc.getSchema()); this.getInSchema().setQualifier(qualifiedAlias); this.setOutSchema(new Schema(getInSchema())); logicalSchema = SchemaUtil.getQualifiedLogicalSchema(tableDesc, qualifiedAlias); }
private void checkIndexExistence(final QueryContext queryContext, final CreateIndexNode createIndexNode) throws DuplicateIndexException { String databaseName, simpleIndexName, qualifiedIndexName; if (CatalogUtil.isFQTableName(createIndexNode.getIndexName())) { String[] splits = CatalogUtil.splitFQTableName(createIndexNode.getIndexName()); databaseName = splits[0]; simpleIndexName = splits[1]; qualifiedIndexName = createIndexNode.getIndexName(); } else { databaseName = queryContext.getCurrentDatabase(); simpleIndexName = createIndexNode.getIndexName(); qualifiedIndexName = CatalogUtil.buildFQName(databaseName, simpleIndexName); } if (catalog.existIndexByName(databaseName, simpleIndexName)) { throw new DuplicateIndexException(qualifiedIndexName); } }
@Override public LogicalNode visitSimpleTableSubquery(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, SimpleTableSubquery expr) throws TajoException { LogicalPlanner.PlanContext newContext; // Note: TableSubQuery always has a table name. // SELECT .... FROM (SELECT ...) TB_NAME <- QueryBlock queryBlock = ctx.getPlan().newQueryBlock(); newContext = new LogicalPlanner.PlanContext(ctx, queryBlock); LogicalNode child = super.visitSimpleTableSubquery(newContext, stack, expr); queryBlock.setRoot(child); // a table subquery should be dealt as a relation. TableSubQueryNode node = ctx.getPlan().createNode(TableSubQueryNode.class); node.init(CatalogUtil.buildFQName(ctx.getQueryContext().get(SessionVars.CURRENT_DATABASE), ctx.generateUniqueSubQueryName()), child); ctx.getQueryBlock().addRelation(node); if (stack.peek().getType() == OpType.InPredicate) { // In-subquery and scalar subquery cannot be the base for name resolution. node.setNameResolveBase(false); } return node; }
public void createIndex(final QueryContext queryContext, final CreateIndexNode createIndexNode) throws DuplicateIndexException, UndefinedTableException, UndefinedDatabaseException { String databaseName, simpleIndexName, qualifiedIndexName; if (CatalogUtil.isFQTableName(createIndexNode.getIndexName())) { String[] splits = CatalogUtil.splitFQTableName(createIndexNode.getIndexName()); databaseName = splits[0]; simpleIndexName = splits[1]; qualifiedIndexName = createIndexNode.getIndexName(); } else { databaseName = queryContext.getCurrentDatabase(); simpleIndexName = createIndexNode.getIndexName(); qualifiedIndexName = CatalogUtil.buildFQName(databaseName, simpleIndexName); } if (catalog.existIndexByName(databaseName, simpleIndexName)) { throw new DuplicateIndexException(simpleIndexName); } ScanNode scanNode = PlannerUtil.findTopNode(createIndexNode, NodeType.SCAN); if (scanNode == null) { throw new InternalError("Cannot find the table of the relation"); } IndexDesc indexDesc = new IndexDesc(databaseName, CatalogUtil.extractSimpleName(scanNode.getTableName()), simpleIndexName, createIndexNode.getIndexPath(), createIndexNode.getKeySortSpecs(), createIndexNode.getIndexMethod(), createIndexNode.isUnique(), false, scanNode.getLogicalSchema()); catalog.createIndex(indexDesc); LOG.info("Index " + qualifiedIndexName + " is created for the table " + scanNode.getTableName() + "."); }
@Override public LogicalNode visitTableSubQuery(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TablePrimarySubQuery expr) throws TajoException { LogicalPlanner.PlanContext newContext; // Note: TableSubQuery always has a table name. // SELECT .... FROM (SELECT ...) TB_NAME <- QueryBlock queryBlock = ctx.getPlan().newQueryBlock(); newContext = new LogicalPlanner.PlanContext(ctx, queryBlock); LogicalNode child = super.visitTableSubQuery(newContext, stack, expr); queryBlock.setRoot(child); // a table subquery should be dealt as a relation. TableSubQueryNode node = ctx.getPlan().createNode(TableSubQueryNode.class); node.init(CatalogUtil.buildFQName(ctx.getQueryContext().get(SessionVars.CURRENT_DATABASE), expr.getName()), child); ctx.getQueryBlock().addRelation(node); return node; }
@Override public TableDescProto getTableDescription() { TableDescProto.Builder tableBuilder = TableDescProto.newBuilder(); tableBuilder.setTableName(CatalogUtil.buildFQName(dictionary.getSystemDatabaseName(), getTableNameString())); tableBuilder.setPath(dictionary.getTablePath()); tableBuilder.setSchema(CatalogUtil.getQualfiedSchema( dictionary.getSystemDatabaseName() + "." + getTableNameString(), getSchemaProto())); tableBuilder.setMeta(getTableProto()); tableBuilder.setStats(getTableStatsProto()); return tableBuilder.build(); }
@Override public void execute(QueryMaster.QueryMasterContext context, QueryContext queryContext, Query query, ExecutionBlockId finalExecBlockId, Path finalOutputDir) throws Exception { CatalogService catalog = context.getWorkerContext().getCatalog(); Stage lastStage = query.getStage(finalExecBlockId); CreateIndexNode createIndexNode = (CreateIndexNode) lastStage.getBlock().getPlan(); String databaseName, simpleIndexName, qualifiedIndexName; if (CatalogUtil.isFQTableName(createIndexNode.getIndexName())) { String [] splits = CatalogUtil.splitFQTableName(createIndexNode.getIndexName()); databaseName = splits[0]; simpleIndexName = splits[1]; qualifiedIndexName = createIndexNode.getIndexName(); } else { databaseName = queryContext.getCurrentDatabase(); simpleIndexName = createIndexNode.getIndexName(); qualifiedIndexName = CatalogUtil.buildFQName(databaseName, simpleIndexName); } ScanNode scanNode = PlannerUtil.findTopNode(createIndexNode, NodeType.SCAN); if (scanNode == null) { throw new IOException("Cannot find the table of the relation"); } IndexDesc indexDesc = new IndexDesc(databaseName, CatalogUtil.extractSimpleName(scanNode.getTableName()), simpleIndexName, createIndexNode.getIndexPath(), createIndexNode.getKeySortSpecs(), createIndexNode.getIndexMethod(), createIndexNode.isUnique(), false, scanNode.getLogicalSchema()); catalog.createIndex(indexDesc); LOG.info("Index " + qualifiedIndexName + " is created for the table " + scanNode.getTableName() + "."); } }
@Override public LogicalNode visitRelation(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Relation relation) throws TajoException { String actualRelationName; if (CatalogUtil.isFQTableName(relation.getName())) { actualRelationName = relation.getName(); } else { actualRelationName = CatalogUtil.buildFQName(ctx.getQueryContext().get(SessionVars.CURRENT_DATABASE), relation.getName()); } TableDesc desc = catalog.getTableDesc(actualRelationName); ScanNode scanNode = ctx.getPlan().createNode(ScanNode.class); if (relation.hasAlias()) { scanNode.init(desc, relation.getAlias()); } else { scanNode.init(desc); } TablePropertyUtil.setTableProperty(ctx.getQueryContext(), scanNode); ctx.getQueryBlock().addRelation(scanNode); return scanNode; }
public LogicalNode handleCreateTableLike(PlanContext context, CreateTable expr, CreateTableNode createTableNode) throws TajoException { String parentTableName = expr.getLikeParentTableName(); if (CatalogUtil.isFQTableName(parentTableName) == false) { parentTableName = CatalogUtil.buildFQName(context.queryContext.get(SessionVars.CURRENT_DATABASE), parentTableName); } TableDesc baseTable = catalog.getTableDesc(parentTableName); if(baseTable == null) { throw new UndefinedTableException(parentTableName); } PartitionMethodDesc partitionDesc = baseTable.getPartitionMethod(); createTableNode.setTableSchema(baseTable.getSchema()); createTableNode.setPartitionMethod(partitionDesc); createTableNode.setDataFormat(CatalogUtil.getBackwardCompitableDataFormat(baseTable.getMeta().getDataFormat())); createTableNode.setOptions(baseTable.getMeta().getOptions()); createTableNode.setExternal(baseTable.isExternal()); if(baseTable.isExternal()) { createTableNode.setUri(baseTable.getUri()); } return createTableNode; }
setOpTableSubQueryNode.init(CatalogUtil.buildFQName(context.queryContext.get(SessionVars.CURRENT_DATABASE), context.generateUniqueSubQueryName()), setOperationNode); setTargetOfTableSubQuery(context, currentBlock, setOpTableSubQueryNode);