Examples with TableAlreadyExistException org.apache.flink.table.catalog.exceptions.TableAlreadyExistException used on opensource projects

Example 1 with TableAlreadyExistException

use of org.apache.flink.table.catalog.exceptions.TableAlreadyExistException in project flink by apache.

the class TableEnvironmentImpl method executeInternal.

@Override
public TableResultInternal executeInternal(Operation operation) {
    if (operation instanceof ModifyOperation) {
        return executeInternal(Collections.singletonList((ModifyOperation) operation));
    } else if (operation instanceof StatementSetOperation) {
        return executeInternal(((StatementSetOperation) operation).getOperations());
    } else if (operation instanceof CreateTableOperation) {
        CreateTableOperation createTableOperation = (CreateTableOperation) operation;
        if (createTableOperation.isTemporary()) {
            catalogManager.createTemporaryTable(createTableOperation.getCatalogTable(), createTableOperation.getTableIdentifier(), createTableOperation.isIgnoreIfExists());
        } else {
            catalogManager.createTable(createTableOperation.getCatalogTable(), createTableOperation.getTableIdentifier(), createTableOperation.isIgnoreIfExists());
        }
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof DropTableOperation) {
        DropTableOperation dropTableOperation = (DropTableOperation) operation;
        if (dropTableOperation.isTemporary()) {
            catalogManager.dropTemporaryTable(dropTableOperation.getTableIdentifier(), dropTableOperation.isIfExists());
        } else {
            catalogManager.dropTable(dropTableOperation.getTableIdentifier(), dropTableOperation.isIfExists());
        }
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof AlterTableOperation) {
        AlterTableOperation alterTableOperation = (AlterTableOperation) operation;
        Catalog catalog = getCatalogOrThrowException(alterTableOperation.getTableIdentifier().getCatalogName());
        String exMsg = getDDLOpExecuteErrorMsg(alterTableOperation.asSummaryString());
        try {
            if (alterTableOperation instanceof AlterTableRenameOperation) {
                AlterTableRenameOperation alterTableRenameOp = (AlterTableRenameOperation) operation;
                catalog.renameTable(alterTableRenameOp.getTableIdentifier().toObjectPath(), alterTableRenameOp.getNewTableIdentifier().getObjectName(), false);
            } else if (alterTableOperation instanceof AlterTableOptionsOperation) {
                AlterTableOptionsOperation alterTablePropertiesOp = (AlterTableOptionsOperation) operation;
                catalogManager.alterTable(alterTablePropertiesOp.getCatalogTable(), alterTablePropertiesOp.getTableIdentifier(), false);
            } else if (alterTableOperation instanceof AlterTableAddConstraintOperation) {
                AlterTableAddConstraintOperation addConstraintOP = (AlterTableAddConstraintOperation) operation;
                CatalogTable oriTable = catalogManager.getTable(addConstraintOP.getTableIdentifier()).get().getTable();
                TableSchema.Builder builder = TableSchemaUtils.builderWithGivenSchema(oriTable.getSchema());
                if (addConstraintOP.getConstraintName().isPresent()) {
                    builder.primaryKey(addConstraintOP.getConstraintName().get(), addConstraintOP.getColumnNames());
                } else {
                    builder.primaryKey(addConstraintOP.getColumnNames());
                }
                CatalogTable newTable = new CatalogTableImpl(builder.build(), oriTable.getPartitionKeys(), oriTable.getOptions(), oriTable.getComment());
                catalogManager.alterTable(newTable, addConstraintOP.getTableIdentifier(), false);
            } else if (alterTableOperation instanceof AlterTableDropConstraintOperation) {
                AlterTableDropConstraintOperation dropConstraintOperation = (AlterTableDropConstraintOperation) operation;
                CatalogTable oriTable = catalogManager.getTable(dropConstraintOperation.getTableIdentifier()).get().getTable();
                CatalogTable newTable = new CatalogTableImpl(TableSchemaUtils.dropConstraint(oriTable.getSchema(), dropConstraintOperation.getConstraintName()), oriTable.getPartitionKeys(), oriTable.getOptions(), oriTable.getComment());
                catalogManager.alterTable(newTable, dropConstraintOperation.getTableIdentifier(), false);
            } else if (alterTableOperation instanceof AlterPartitionPropertiesOperation) {
                AlterPartitionPropertiesOperation alterPartPropsOp = (AlterPartitionPropertiesOperation) operation;
                catalog.alterPartition(alterPartPropsOp.getTableIdentifier().toObjectPath(), alterPartPropsOp.getPartitionSpec(), alterPartPropsOp.getCatalogPartition(), false);
            } else if (alterTableOperation instanceof AlterTableSchemaOperation) {
                AlterTableSchemaOperation alterTableSchemaOperation = (AlterTableSchemaOperation) alterTableOperation;
                catalogManager.alterTable(alterTableSchemaOperation.getCatalogTable(), alterTableSchemaOperation.getTableIdentifier(), false);
            } else if (alterTableOperation instanceof AddPartitionsOperation) {
                AddPartitionsOperation addPartitionsOperation = (AddPartitionsOperation) alterTableOperation;
                List<CatalogPartitionSpec> specs = addPartitionsOperation.getPartitionSpecs();
                List<CatalogPartition> partitions = addPartitionsOperation.getCatalogPartitions();
                boolean ifNotExists = addPartitionsOperation.ifNotExists();
                ObjectPath tablePath = addPartitionsOperation.getTableIdentifier().toObjectPath();
                for (int i = 0; i < specs.size(); i++) {
                    catalog.createPartition(tablePath, specs.get(i), partitions.get(i), ifNotExists);
                }
            } else if (alterTableOperation instanceof DropPartitionsOperation) {
                DropPartitionsOperation dropPartitionsOperation = (DropPartitionsOperation) alterTableOperation;
                ObjectPath tablePath = dropPartitionsOperation.getTableIdentifier().toObjectPath();
                boolean ifExists = dropPartitionsOperation.ifExists();
                for (CatalogPartitionSpec spec : dropPartitionsOperation.getPartitionSpecs()) {
                    catalog.dropPartition(tablePath, spec, ifExists);
                }
            }
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (TableAlreadyExistException | TableNotExistException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof CreateViewOperation) {
        CreateViewOperation createViewOperation = (CreateViewOperation) operation;
        if (createViewOperation.isTemporary()) {
            catalogManager.createTemporaryTable(createViewOperation.getCatalogView(), createViewOperation.getViewIdentifier(), createViewOperation.isIgnoreIfExists());
        } else {
            catalogManager.createTable(createViewOperation.getCatalogView(), createViewOperation.getViewIdentifier(), createViewOperation.isIgnoreIfExists());
        }
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof DropViewOperation) {
        DropViewOperation dropViewOperation = (DropViewOperation) operation;
        if (dropViewOperation.isTemporary()) {
            catalogManager.dropTemporaryView(dropViewOperation.getViewIdentifier(), dropViewOperation.isIfExists());
        } else {
            catalogManager.dropView(dropViewOperation.getViewIdentifier(), dropViewOperation.isIfExists());
        }
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof AlterViewOperation) {
        AlterViewOperation alterViewOperation = (AlterViewOperation) operation;
        Catalog catalog = getCatalogOrThrowException(alterViewOperation.getViewIdentifier().getCatalogName());
        String exMsg = getDDLOpExecuteErrorMsg(alterViewOperation.asSummaryString());
        try {
            if (alterViewOperation instanceof AlterViewRenameOperation) {
                AlterViewRenameOperation alterTableRenameOp = (AlterViewRenameOperation) operation;
                catalog.renameTable(alterTableRenameOp.getViewIdentifier().toObjectPath(), alterTableRenameOp.getNewViewIdentifier().getObjectName(), false);
            } else if (alterViewOperation instanceof AlterViewPropertiesOperation) {
                AlterViewPropertiesOperation alterTablePropertiesOp = (AlterViewPropertiesOperation) operation;
                catalogManager.alterTable(alterTablePropertiesOp.getCatalogView(), alterTablePropertiesOp.getViewIdentifier(), false);
            } else if (alterViewOperation instanceof AlterViewAsOperation) {
                AlterViewAsOperation alterViewAsOperation = (AlterViewAsOperation) alterViewOperation;
                catalogManager.alterTable(alterViewAsOperation.getNewView(), alterViewAsOperation.getViewIdentifier(), false);
            }
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (TableAlreadyExistException | TableNotExistException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof CreateDatabaseOperation) {
        CreateDatabaseOperation createDatabaseOperation = (CreateDatabaseOperation) operation;
        Catalog catalog = getCatalogOrThrowException(createDatabaseOperation.getCatalogName());
        String exMsg = getDDLOpExecuteErrorMsg(createDatabaseOperation.asSummaryString());
        try {
            catalog.createDatabase(createDatabaseOperation.getDatabaseName(), createDatabaseOperation.getCatalogDatabase(), createDatabaseOperation.isIgnoreIfExists());
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (DatabaseAlreadyExistException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof DropDatabaseOperation) {
        DropDatabaseOperation dropDatabaseOperation = (DropDatabaseOperation) operation;
        Catalog catalog = getCatalogOrThrowException(dropDatabaseOperation.getCatalogName());
        String exMsg = getDDLOpExecuteErrorMsg(dropDatabaseOperation.asSummaryString());
        try {
            catalog.dropDatabase(dropDatabaseOperation.getDatabaseName(), dropDatabaseOperation.isIfExists(), dropDatabaseOperation.isCascade());
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (DatabaseNotExistException | DatabaseNotEmptyException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof AlterDatabaseOperation) {
        AlterDatabaseOperation alterDatabaseOperation = (AlterDatabaseOperation) operation;
        Catalog catalog = getCatalogOrThrowException(alterDatabaseOperation.getCatalogName());
        String exMsg = getDDLOpExecuteErrorMsg(alterDatabaseOperation.asSummaryString());
        try {
            catalog.alterDatabase(alterDatabaseOperation.getDatabaseName(), alterDatabaseOperation.getCatalogDatabase(), false);
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (DatabaseNotExistException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof CreateCatalogFunctionOperation) {
        return createCatalogFunction((CreateCatalogFunctionOperation) operation);
    } else if (operation instanceof CreateTempSystemFunctionOperation) {
        return createSystemFunction((CreateTempSystemFunctionOperation) operation);
    } else if (operation instanceof DropCatalogFunctionOperation) {
        return dropCatalogFunction((DropCatalogFunctionOperation) operation);
    } else if (operation instanceof DropTempSystemFunctionOperation) {
        return dropSystemFunction((DropTempSystemFunctionOperation) operation);
    } else if (operation instanceof AlterCatalogFunctionOperation) {
        return alterCatalogFunction((AlterCatalogFunctionOperation) operation);
    } else if (operation instanceof CreateCatalogOperation) {
        return createCatalog((CreateCatalogOperation) operation);
    } else if (operation instanceof DropCatalogOperation) {
        DropCatalogOperation dropCatalogOperation = (DropCatalogOperation) operation;
        String exMsg = getDDLOpExecuteErrorMsg(dropCatalogOperation.asSummaryString());
        try {
            catalogManager.unregisterCatalog(dropCatalogOperation.getCatalogName(), dropCatalogOperation.isIfExists());
            return TableResultImpl.TABLE_RESULT_OK;
        } catch (CatalogException e) {
            throw new ValidationException(exMsg, e);
        }
    } else if (operation instanceof LoadModuleOperation) {
        return loadModule((LoadModuleOperation) operation);
    } else if (operation instanceof UnloadModuleOperation) {
        return unloadModule((UnloadModuleOperation) operation);
    } else if (operation instanceof UseModulesOperation) {
        return useModules((UseModulesOperation) operation);
    } else if (operation instanceof UseCatalogOperation) {
        UseCatalogOperation useCatalogOperation = (UseCatalogOperation) operation;
        catalogManager.setCurrentCatalog(useCatalogOperation.getCatalogName());
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof UseDatabaseOperation) {
        UseDatabaseOperation useDatabaseOperation = (UseDatabaseOperation) operation;
        catalogManager.setCurrentCatalog(useDatabaseOperation.getCatalogName());
        catalogManager.setCurrentDatabase(useDatabaseOperation.getDatabaseName());
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof ShowCatalogsOperation) {
        return buildShowResult("catalog name", listCatalogs());
    } else if (operation instanceof ShowCreateTableOperation) {
        ShowCreateTableOperation showCreateTableOperation = (ShowCreateTableOperation) operation;
        ContextResolvedTable table = catalogManager.getTable(showCreateTableOperation.getTableIdentifier()).orElseThrow(() -> new ValidationException(String.format("Could not execute SHOW CREATE TABLE. Table with identifier %s does not exist.", showCreateTableOperation.getTableIdentifier().asSerializableString())));
        return TableResultImpl.builder().resultKind(ResultKind.SUCCESS_WITH_CONTENT).schema(ResolvedSchema.of(Column.physical("result", DataTypes.STRING()))).data(Collections.singletonList(Row.of(ShowCreateUtil.buildShowCreateTableRow(table.getResolvedTable(), showCreateTableOperation.getTableIdentifier(), table.isTemporary())))).build();
    } else if (operation instanceof ShowCreateViewOperation) {
        ShowCreateViewOperation showCreateViewOperation = (ShowCreateViewOperation) operation;
        final ContextResolvedTable table = catalogManager.getTable(showCreateViewOperation.getViewIdentifier()).orElseThrow(() -> new ValidationException(String.format("Could not execute SHOW CREATE VIEW. View with identifier %s does not exist.", showCreateViewOperation.getViewIdentifier().asSerializableString())));
        return TableResultImpl.builder().resultKind(ResultKind.SUCCESS_WITH_CONTENT).schema(ResolvedSchema.of(Column.physical("result", DataTypes.STRING()))).data(Collections.singletonList(Row.of(ShowCreateUtil.buildShowCreateViewRow(table.getResolvedTable(), showCreateViewOperation.getViewIdentifier(), table.isTemporary())))).build();
    } else if (operation instanceof ShowCurrentCatalogOperation) {
        return buildShowResult("current catalog name", new String[] { catalogManager.getCurrentCatalog() });
    } else if (operation instanceof ShowDatabasesOperation) {
        return buildShowResult("database name", listDatabases());
    } else if (operation instanceof ShowCurrentDatabaseOperation) {
        return buildShowResult("current database name", new String[] { catalogManager.getCurrentDatabase() });
    } else if (operation instanceof ShowModulesOperation) {
        ShowModulesOperation showModulesOperation = (ShowModulesOperation) operation;
        if (showModulesOperation.requireFull()) {
            return buildShowFullModulesResult(listFullModules());
        } else {
            return buildShowResult("module name", listModules());
        }
    } else if (operation instanceof ShowTablesOperation) {
        return buildShowResult("table name", listTables());
    } else if (operation instanceof ShowFunctionsOperation) {
        ShowFunctionsOperation showFunctionsOperation = (ShowFunctionsOperation) operation;
        String[] functionNames = null;
        ShowFunctionsOperation.FunctionScope functionScope = showFunctionsOperation.getFunctionScope();
        switch(functionScope) {
            case USER:
                functionNames = listUserDefinedFunctions();
                break;
            case ALL:
                functionNames = listFunctions();
                break;
            default:
                throw new UnsupportedOperationException(String.format("SHOW FUNCTIONS with %s scope is not supported.", functionScope));
        }
        return buildShowResult("function name", functionNames);
    } else if (operation instanceof ShowViewsOperation) {
        return buildShowResult("view name", listViews());
    } else if (operation instanceof ShowColumnsOperation) {
        ShowColumnsOperation showColumnsOperation = (ShowColumnsOperation) operation;
        Optional<ContextResolvedTable> result = catalogManager.getTable(showColumnsOperation.getTableIdentifier());
        if (result.isPresent()) {
            return buildShowColumnsResult(result.get().getResolvedSchema(), showColumnsOperation);
        } else {
            throw new ValidationException(String.format("Tables or views with the identifier '%s' doesn't exist.", showColumnsOperation.getTableIdentifier().asSummaryString()));
        }
    } else if (operation instanceof ShowPartitionsOperation) {
        String exMsg = getDDLOpExecuteErrorMsg(operation.asSummaryString());
        try {
            ShowPartitionsOperation showPartitionsOperation = (ShowPartitionsOperation) operation;
            Catalog catalog = getCatalogOrThrowException(showPartitionsOperation.getTableIdentifier().getCatalogName());
            ObjectPath tablePath = showPartitionsOperation.getTableIdentifier().toObjectPath();
            CatalogPartitionSpec partitionSpec = showPartitionsOperation.getPartitionSpec();
            List<CatalogPartitionSpec> partitionSpecs = partitionSpec == null ? catalog.listPartitions(tablePath) : catalog.listPartitions(tablePath, partitionSpec);
            List<String> partitionNames = new ArrayList<>(partitionSpecs.size());
            for (CatalogPartitionSpec spec : partitionSpecs) {
                List<String> partitionKVs = new ArrayList<>(spec.getPartitionSpec().size());
                for (Map.Entry<String, String> partitionKV : spec.getPartitionSpec().entrySet()) {
                    partitionKVs.add(partitionKV.getKey() + "=" + partitionKV.getValue());
                }
                partitionNames.add(String.join("/", partitionKVs));
            }
            return buildShowResult("partition name", partitionNames.toArray(new String[0]));
        } catch (TableNotExistException e) {
            throw new ValidationException(exMsg, e);
        } catch (Exception e) {
            throw new TableException(exMsg, e);
        }
    } else if (operation instanceof ExplainOperation) {
        ExplainOperation explainOperation = (ExplainOperation) operation;
        ExplainDetail[] explainDetails = explainOperation.getExplainDetails().stream().map(ExplainDetail::valueOf).toArray(ExplainDetail[]::new);
        Operation child = ((ExplainOperation) operation).getChild();
        List<Operation> operations;
        if (child instanceof StatementSetOperation) {
            operations = new ArrayList<>(((StatementSetOperation) child).getOperations());
        } else {
            operations = Collections.singletonList(child);
        }
        String explanation = explainInternal(operations, explainDetails);
        return TableResultImpl.builder().resultKind(ResultKind.SUCCESS_WITH_CONTENT).schema(ResolvedSchema.of(Column.physical("result", DataTypes.STRING()))).data(Collections.singletonList(Row.of(explanation))).build();
    } else if (operation instanceof DescribeTableOperation) {
        DescribeTableOperation describeTableOperation = (DescribeTableOperation) operation;
        Optional<ContextResolvedTable> result = catalogManager.getTable(describeTableOperation.getSqlIdentifier());
        if (result.isPresent()) {
            return buildDescribeResult(result.get().getResolvedSchema());
        } else {
            throw new ValidationException(String.format("Tables or views with the identifier '%s' doesn't exist", describeTableOperation.getSqlIdentifier().asSummaryString()));
        }
    } else if (operation instanceof QueryOperation) {
        return executeQueryOperation((QueryOperation) operation);
    } else if (operation instanceof CreateTableASOperation) {
        CreateTableASOperation createTableASOperation = (CreateTableASOperation) operation;
        executeInternal(createTableASOperation.getCreateTableOperation());
        return executeInternal(createTableASOperation.toSinkModifyOperation(catalogManager));
    } else if (operation instanceof ExecutePlanOperation) {
        ExecutePlanOperation executePlanOperation = (ExecutePlanOperation) operation;
        return (TableResultInternal) executePlan(PlanReference.fromFile(executePlanOperation.getFilePath()));
    } else if (operation instanceof CompilePlanOperation) {
        CompilePlanOperation compilePlanOperation = (CompilePlanOperation) operation;
        compilePlanAndWrite(compilePlanOperation.getFilePath(), compilePlanOperation.isIfNotExists(), compilePlanOperation.getOperation());
        return TableResultImpl.TABLE_RESULT_OK;
    } else if (operation instanceof CompileAndExecutePlanOperation) {
        CompileAndExecutePlanOperation compileAndExecutePlanOperation = (CompileAndExecutePlanOperation) operation;
        CompiledPlan compiledPlan = compilePlanAndWrite(compileAndExecutePlanOperation.getFilePath(), true, compileAndExecutePlanOperation.getOperation());
        return (TableResultInternal) executePlan(compiledPlan);
    } else if (operation instanceof NopOperation) {
        return TableResultImpl.TABLE_RESULT_OK;
    } else {
        throw new TableException(UNSUPPORTED_QUERY_IN_EXECUTE_SQL_MSG);
    }
}

Example 2 with TableAlreadyExistException

use of org.apache.flink.table.catalog.exceptions.TableAlreadyExistException in project flink by apache.

the class HiveCatalog method renameTable.

@Override
public void renameTable(ObjectPath tablePath, String newTableName, boolean ignoreIfNotExists) throws TableNotExistException, TableAlreadyExistException, CatalogException {
    checkNotNull(tablePath, "tablePath cannot be null");
    checkArgument(!isNullOrWhitespaceOnly(newTableName), "newTableName cannot be null or empty");
    try {
        // Thus, check the table existence explicitly
        if (tableExists(tablePath)) {
            ObjectPath newPath = new ObjectPath(tablePath.getDatabaseName(), newTableName);
            // Thus, check the table existence explicitly
            if (tableExists(newPath)) {
                throw new TableAlreadyExistException(getName(), newPath);
            } else {
                Table table = getHiveTable(tablePath);
                table.setTableName(newTableName);
                client.alter_table(tablePath.getDatabaseName(), tablePath.getObjectName(), table);
            }
        } else if (!ignoreIfNotExists) {
            throw new TableNotExistException(getName(), tablePath);
        }
    } catch (TException e) {
        throw new CatalogException(String.format("Failed to rename table %s", tablePath.getFullName()), e);
    }
}

Example 3 with TableAlreadyExistException

use of org.apache.flink.table.catalog.exceptions.TableAlreadyExistException in project flink by apache.

the class HiveCatalog method createTable.

@Override
public void createTable(ObjectPath tablePath, CatalogBaseTable table, boolean ignoreIfExists) throws TableAlreadyExistException, DatabaseNotExistException, CatalogException {
    checkNotNull(tablePath, "tablePath cannot be null");
    checkNotNull(table, "table cannot be null");
    if (!databaseExists(tablePath.getDatabaseName())) {
        throw new DatabaseNotExistException(getName(), tablePath.getDatabaseName());
    }
    boolean managedTable = ManagedTableListener.isManagedTable(this, table);
    Table hiveTable = HiveTableUtil.instantiateHiveTable(tablePath, table, hiveConf, managedTable);
    UniqueConstraint pkConstraint = null;
    List<String> notNullCols = new ArrayList<>();
    boolean isHiveTable = isHiveTable(table.getOptions());
    if (isHiveTable) {
        pkConstraint = table.getSchema().getPrimaryKey().orElse(null);
        String nnColStr = hiveTable.getParameters().remove(NOT_NULL_COLS);
        if (nnColStr != null) {
            notNullCols.addAll(Arrays.asList(nnColStr.split(HiveDDLUtils.COL_DELIMITER)));
        } else {
            for (int i = 0; i < table.getSchema().getFieldDataTypes().length; i++) {
                if (!table.getSchema().getFieldDataTypes()[i].getLogicalType().isNullable()) {
                    notNullCols.add(table.getSchema().getFieldNames()[i]);
                }
            }
        }
        // remove the 'connector' option for hive table
        hiveTable.getParameters().remove(CONNECTOR.key());
    }
    try {
        if (pkConstraint != null || !notNullCols.isEmpty()) {
            // extract constraint traits from table properties
            String pkTraitStr = hiveTable.getParameters().remove(PK_CONSTRAINT_TRAIT);
            byte pkTrait = pkTraitStr == null ? HiveDDLUtils.defaultTrait() : Byte.parseByte(pkTraitStr);
            List<Byte> pkTraits = Collections.nCopies(pkConstraint == null ? 0 : pkConstraint.getColumns().size(), pkTrait);
            List<Byte> nnTraits;
            String nnTraitsStr = hiveTable.getParameters().remove(NOT_NULL_CONSTRAINT_TRAITS);
            if (nnTraitsStr != null) {
                String[] traits = nnTraitsStr.split(HiveDDLUtils.COL_DELIMITER);
                Preconditions.checkArgument(traits.length == notNullCols.size(), "Number of NOT NULL columns and constraint traits mismatch");
                nnTraits = Arrays.stream(traits).map(Byte::new).collect(Collectors.toList());
            } else {
                nnTraits = Collections.nCopies(notNullCols.size(), HiveDDLUtils.defaultTrait());
            }
            client.createTableWithConstraints(hiveTable, hiveConf, pkConstraint, pkTraits, notNullCols, nnTraits);
        } else {
            client.createTable(hiveTable);
        }
    } catch (AlreadyExistsException e) {
        if (!ignoreIfExists) {
            throw new TableAlreadyExistException(getName(), tablePath, e);
        }
    } catch (TException e) {
        throw new CatalogException(String.format("Failed to create table %s", tablePath.getFullName()), e);
    }
}

Example 4 with TableAlreadyExistException

use of org.apache.flink.table.catalog.exceptions.TableAlreadyExistException in project flink by apache.

the class GenericInMemoryCatalog method renameTable.

@Override
public void renameTable(ObjectPath tablePath, String newTableName, boolean ignoreIfNotExists) throws TableNotExistException, TableAlreadyExistException {
    checkNotNull(tablePath);
    checkArgument(!StringUtils.isNullOrWhitespaceOnly(newTableName));
    if (tableExists(tablePath)) {
        ObjectPath newPath = new ObjectPath(tablePath.getDatabaseName(), newTableName);
        if (tableExists(newPath)) {
            throw new TableAlreadyExistException(getName(), newPath);
        } else {
            tables.put(newPath, tables.remove(tablePath));
            // table statistics
            if (tableStats.containsKey(tablePath)) {
                tableStats.put(newPath, tableStats.remove(tablePath));
            }
            // table column statistics
            if (tableColumnStats.containsKey(tablePath)) {
                tableColumnStats.put(newPath, tableColumnStats.remove(tablePath));
            }
            // partitions
            if (partitions.containsKey(tablePath)) {
                partitions.put(newPath, partitions.remove(tablePath));
            }
            // partition statistics
            if (partitionStats.containsKey(tablePath)) {
                partitionStats.put(newPath, partitionStats.remove(tablePath));
            }
            // partition column statistics
            if (partitionColumnStats.containsKey(tablePath)) {
                partitionColumnStats.put(newPath, partitionColumnStats.remove(tablePath));
            }
        }
    } else if (!ignoreIfNotExists) {
        throw new TableNotExistException(getName(), tablePath);
    }
}