/** * * @return The simple name without qualifications */ public String getSimpleName() { return IdentifierUtil.extractSimpleName(name); }
public String getColumnName() { return IdentifierUtil.extractSimpleName(field.name().interned()); }
public static Pair<String, String> separateQualifierAndName(String name) { Preconditions.checkArgument(isFQTableName(name), "Must be a qualified name."); return new Pair<>(extractQualifier(name), extractSimpleName(name)); }
/** * Guess a relation from a table name regardless of whether the given name is qualified or not. * * @param block the current block * @param tableName The table name which can be either qualified or not. * @return A corresponding relation */ public static RelationNode lookupTable(LogicalPlan.QueryBlock block, String tableName) throws AmbiguousTableException { List<RelationNode> found = new ArrayList<>(); for (RelationNode relation : block.getRelations()) { // if a table name is qualified if (relation.getCanonicalName().equals(tableName) || relation.getTableName().equals(tableName)) { found.add(relation); // if a table name is not qualified } else if (IdentifierUtil.extractSimpleName(relation.getCanonicalName()).equals(tableName) || IdentifierUtil.extractSimpleName(relation.getTableName()).equals(tableName)) { found.add(relation); } } if (found.size() == 0) { return null; } else if (found.size() > 1) { throw new AmbiguousTableException(tableName); } return found.get(0); }
pstmt = conn.prepareStatement(existColumnSql); pstmt.setInt(1, tableId); pstmt.setString(2, extractSimpleName(columnProto.getName())); resultSet = pstmt.executeQuery(); pstmt.setString(2, extractSimpleName(columnProto.getName())); pstmt.setInt(3, position + 1); pstmt.setString(4, TypeStringEncoder.encode(type));
@Override public long getTableVolume(TableDesc table, Optional<EvalNode> filter) { String sql = "SELECT pg_table_size('" + IdentifierUtil.extractSimpleName(table.getName()) + "')"; try (Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(sql)) { if (rs.next()) { return rs.getLong(1); } else { throw new TajoRuntimeException(new UndefinedTableException(table.getName())); } } catch (SQLException e) { throw new TajoInternalError(e); } } }
sb.append(index.getIndexMethod()).append(" ("); for (SortSpecProto key : index.getKeySortSpecsList()) { sb.append(IdentifierUtil.extractSimpleName(key.getColumn().getName())); sb.append(key.getAscending() ? " ASC" : " DESC"); sb.append(key.getNullFirst() ? " NULLS FIRST, " : " NULLS LAST, ");
private List<Tuple> fetchSystemTable(TableDesc tableDesc, Schema inSchema) { List<Tuple> tuples = null; String tableName = IdentifierUtil.extractSimpleName(tableDesc.getName()); if ("tablespace".equalsIgnoreCase(tableName)) { tuples = getTablespaces(inSchema); } else if ("databases".equalsIgnoreCase(tableName)) { tuples = getDatabases(inSchema); } else if ("tables".equalsIgnoreCase(tableName)) { tuples = getTables(inSchema); } else if ("columns".equalsIgnoreCase(tableName)) { tuples = getColumns(inSchema); } else if ("indexes".equalsIgnoreCase(tableName)) { tuples = getIndexes(inSchema); } else if ("table_options".equalsIgnoreCase(tableName)) { tuples = getAllTableOptions(inSchema); } else if ("table_stats".equalsIgnoreCase(tableName)) { tuples = getAllTableStats(inSchema); } else if ("partitions".equalsIgnoreCase(tableName)) { tuples = getAllPartitions(inSchema); } else if ("cluster".equalsIgnoreCase(tableName)) { tuples = getClusterInfo(inSchema); } else if ("session".equalsIgnoreCase(tableName)) { tuples = getSessionInfo(inSchema); } return tuples; }
partitionName.append(File.separator); partitionName.append(IdentifierUtil.extractSimpleName(parititonColumns.get(i).getName())); partitionName.append("="); partitionName.append(hivePartition.getValues().get(i));
@Override public Response run(JerseyResourceDelegateContext context) { JerseyResourceDelegateContextKey<String> databaseNameKey = JerseyResourceDelegateContextKey.valueOf(databaseNameKeyName, String.class); String databaseName = context.get(databaseNameKey).toLowerCase(); JerseyResourceDelegateContextKey<String> tableNameKey = JerseyResourceDelegateContextKey.valueOf(tableNameKeyName, String.class); String tableName = context.get(tableNameKey).toLowerCase(); JerseyResourceDelegateContextKey<MasterContext> masterContextKey = JerseyResourceDelegateContextKey.valueOf(JerseyResourceDelegateUtil.MasterContextKey, MasterContext.class); MasterContext masterContext = context.get(masterContextKey); if (IdentifierUtil.isFQTableName(tableName)) { tableName = IdentifierUtil.extractSimpleName(tableName); } CatalogService catalogService = masterContext.getCatalog(); if (!catalogService.existDatabase(databaseName) || !catalogService.existsTable(databaseName, tableName)) { return Response.status(Status.NOT_FOUND).build(); } TableDesc tableDesc = null; try { tableDesc = catalogService.getTableDesc(databaseName, tableName); return Response.ok(tableDesc).build(); } catch (TajoException e) { return ResourcesUtil.createExceptionResponse(LOG, e.getMessage()); } } }
@Test public void testGetTable() throws Exception { String tableName = "testgettable"; String sessionId = generateNewSessionAndGetId(); createNewTableForTestCreateTable(tableName, sessionId); TableDesc selectedTable = restClient.target(tablesURI) .path("/{tableName}").resolveTemplate("tableName", tableName) .request().get(new GenericType<>(TableDesc.class)); assertNotNull(selectedTable); assertTrue(StringUtils.equalsIgnoreCase(tableName, IdentifierUtil.extractSimpleName(selectedTable.getName()))); }
@Override protected EvalNode visitField(Context context, FieldEval field, Stack<EvalNode> stack) { // strip the database name String tableName; if (IdentifierUtil.isSimpleIdentifier(field.getQualifier())) { tableName = field.getQualifier(); } else { tableName = IdentifierUtil.extractSimpleName(field.getQualifier()); } context.append(IdentifierUtil.buildFQName(tableName, field.getColumnName())); return field; }
@Test public void testDropTable() throws Exception { String tableName = "testdroptable"; String sessionId = generateNewSessionAndGetId(); createNewTableForTestCreateTable(tableName, sessionId); TableDesc selectedTable = restClient.target(tablesURI) .path("/{tableName}").resolveTemplate("tableName", tableName) .request().get(new GenericType<>(TableDesc.class)); assertNotNull(selectedTable); assertTrue(StringUtils.equalsIgnoreCase(tableName, IdentifierUtil.extractSimpleName(selectedTable.getName()))); Response response = restClient.target(tablesURI) .path("/{tableName}").resolveTemplate("tableName", tableName) .request().delete(); assertNotNull(response); assertEquals(Status.OK.getStatusCode(), response.getStatus()); }
@Test public void testGetAllTable() throws Exception { String tableName = "testgetalltable"; String sessionId = generateNewSessionAndGetId(); createNewTableForTestCreateTable(tableName, sessionId); Map<String, Collection<String>> tables = restClient.target(tablesURI) .request().get(new GenericType<>(Map.class)); List<String> tableNames = (List<String>)tables.get("tables"); assertNotNull(tableNames); assertTrue(!tableNames.isEmpty()); boolean tableFound = false; for (String table: tableNames) { if (StringUtils.equalsIgnoreCase(tableName, IdentifierUtil.extractSimpleName(table))) { tableFound = true; break; } } assertTrue(tableFound); }
tableName = IdentifierUtil.extractSimpleName(tableName);
/** * Return a table uri to be created * * @param context PlanContext * @param createTable An algebral expression for create table * @return a Table uri to be created on a given table space */ private URI getCreatedTableURI(PlanContext context, CreateTable createTable) { if (createTable.hasLocation()) { URI tableUri = URI.create(createTable.getLocation()); if (tableUri.getScheme() == null) { // if a given table URI is a just path, the default tablespace will be added. tableUri = URI.create(context.queryContext.get(QueryVars.DEFAULT_SPACE_ROOT_URI) + createTable.getLocation()); } return tableUri; } else { String tableName = createTable.getTableName(); String databaseName = IdentifierUtil.isFQTableName(tableName) ? IdentifierUtil.extractQualifier(tableName) : context.queryContext.get(SessionVars.CURRENT_DATABASE); return storage.getTableURI( createTable.getTableSpaceName(), new TableMeta(createTable.getStorageType(), new KeyValueSet(createTable.getParams())), databaseName, IdentifierUtil.extractSimpleName(tableName)); } }
public void createIndex(final QueryContext queryContext, final CreateIndexNode createIndexNode) throws DuplicateIndexException, UndefinedTableException, UndefinedDatabaseException { String databaseName, simpleIndexName, qualifiedIndexName; if (IdentifierUtil.isFQTableName(createIndexNode.getIndexName())) { String[] splits = IdentifierUtil.splitFQTableName(createIndexNode.getIndexName()); databaseName = splits[0]; simpleIndexName = splits[1]; qualifiedIndexName = createIndexNode.getIndexName(); } else { databaseName = queryContext.getCurrentDatabase(); simpleIndexName = createIndexNode.getIndexName(); qualifiedIndexName = IdentifierUtil.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, IdentifierUtil.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 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 (IdentifierUtil.isFQTableName(createIndexNode.getIndexName())) { String [] splits = IdentifierUtil.splitFQTableName(createIndexNode.getIndexName()); databaseName = splits[0]; simpleIndexName = splits[1]; qualifiedIndexName = createIndexNode.getIndexName(); } else { databaseName = queryContext.getCurrentDatabase(); simpleIndexName = createIndexNode.getIndexName(); qualifiedIndexName = IdentifierUtil.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, IdentifierUtil.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() + "."); } }
IdentifierUtil.buildFQName(relationOp.getCanonicalName(), IdentifierUtil.extractSimpleName(canonicalName));
String simpleNewTableName = extractSimpleName(alterTableDescProto.getNewTableName()); if (existTable(databaseName, simpleNewTableName)) { throw new DuplicateTableException(alterTableDescProto.getNewTableName());