in asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java [104:408]
public void validateOperation(ICcApplicationContext appCtx, Namespace activeNamespace, Statement stmt)
throws AlgebricksException {
final IClusterStateManager clusterStateManager = appCtx.getClusterStateManager();
final IGlobalRecoveryManager globalRecoveryManager = appCtx.getGlobalRecoveryManager();
if (!(clusterStateManager.getState().equals(ClusterState.ACTIVE)
&& globalRecoveryManager.isRecoveryCompleted())) {
int maxWaitCycles = appCtx.getExternalProperties().getMaxWaitClusterActive();
try {
clusterStateManager.waitForState(ClusterState.ACTIVE, maxWaitCycles, TimeUnit.SECONDS);
} catch (HyracksDataException e) {
throw new AlgebricksException(TIMEOUT, e);
} catch (InterruptedException e) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Thread interrupted while waiting for cluster to be " + ClusterState.ACTIVE);
}
Thread.currentThread().interrupt();
}
synchronized (clusterStateManager) {
if (!clusterStateManager.getState().equals(ClusterState.ACTIVE)) {
ClusterPartition[] configuredPartitions = clusterStateManager.getClusterPartitons();
Set<String> inactiveNodes = new HashSet<>();
for (ClusterPartition cp : configuredPartitions) {
if (!cp.isActive()) {
inactiveNodes.add(cp.getNodeId());
}
}
throw AsterixException.create(ErrorCode.CLUSTER_STATE_UNUSABLE,
Arrays.toString(inactiveNodes.toArray()));
} else {
if (LOGGER.isInfoEnabled()) {
LOGGER.info("Cluster is now " + ClusterState.ACTIVE);
}
}
}
}
if (!globalRecoveryManager.isRecoveryCompleted()) {
int maxWaitCycles = appCtx.getExternalProperties().getMaxWaitClusterActive();
int waitCycleCount = 0;
try {
while (!globalRecoveryManager.isRecoveryCompleted() && waitCycleCount < maxWaitCycles) {
Thread.sleep(1000);
waitCycleCount++;
}
} catch (InterruptedException e) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Thread interrupted while waiting for cluster to complete global recovery ");
}
Thread.currentThread().interrupt();
}
if (!globalRecoveryManager.isRecoveryCompleted()) {
throw new AsterixException("Cluster Global recovery is not yet complete and the system is in "
+ ClusterState.ACTIVE + " state");
}
}
boolean usingDb = appCtx.getNamespaceResolver().isUsingDatabase();
boolean invalidOperation = false;
String message = null;
DataverseName dataverseName;
Namespace namespace;
switch (stmt.getKind()) {
case LOAD:
namespace = getStatementNamespace(((LoadStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatDmlMessage("Load", namespace, usingDb);
}
break;
case INSERT:
namespace = getStatementNamespace(((InsertStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatDmlMessage("Insert", namespace, usingDb);
}
break;
case UPSERT:
namespace = getStatementNamespace(((UpsertStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatDmlMessage("Upsert", namespace, usingDb);
}
break;
case DELETE:
namespace = getStatementNamespace(((DeleteStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatDmlMessage("Delete", namespace, usingDb);
}
break;
case CREATE_DATABASE: {
CreateDatabaseStatement dbCreateStmt = (CreateDatabaseStatement) stmt;
String dbName = dbCreateStmt.getDatabaseName().getValue();
invalidOperation = isSystemDatabase(dbName) || isDefaultDatabase(dbName) || isReservedDatabase(dbName);
if (invalidOperation) {
message = String.format("Cannot create database: %s", dbName);
}
break;
}
case DATABASE_DROP: {
DatabaseDropStatement dbDropStmt = (DatabaseDropStatement) stmt;
String dbName = dbDropStmt.getDatabaseName().getValue();
invalidOperation = isSystemDatabase(dbName) || isDefaultDatabase(dbName);
if (invalidOperation) {
message = String.format("Cannot drop database: %s", dbName);
}
break;
}
case CREATE_DATAVERSE:
CreateDataverseStatement dvCreateStmt = (CreateDataverseStatement) stmt;
dataverseName = dvCreateStmt.getDataverseName();
invalidOperation = FunctionConstants.ASTERIX_DV.equals(dataverseName)
|| FunctionConstants.ALGEBRICKS_DV.equals(dataverseName) || isMetadataDataverse(dataverseName)
|| isDefaultDataverse(dataverseName) || isSystemDatabase(dvCreateStmt.getDatabaseName());
if (invalidOperation) {
message = formatDdlMessage("create", dataverseName, dvCreateStmt.getDatabaseName(), usingDb);
}
break;
case DATAVERSE_DROP:
DataverseDropStatement dvDropStmt = (DataverseDropStatement) stmt;
dataverseName = dvDropStmt.getDataverseName();
invalidOperation = isMetadataDataverse(dataverseName) || isDefaultDataverse(dataverseName)
|| isSystemDatabase(dvDropStmt.getDatabaseName());
if (invalidOperation) {
message = formatDdlMessage("drop", dataverseName, dvDropStmt.getDatabaseName(), usingDb);
}
break;
case DATASET_DECL:
DatasetDecl dsCreateStmt = (DatasetDecl) stmt;
namespace = getStatementNamespace(((DatasetDecl) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", dataset(), namespace, usingDb);
}
if (!invalidOperation) {
Map<String, String> hints = dsCreateStmt.getHints();
if (hints != null && !hints.isEmpty()) {
StringBuilder errorMsgBuffer = new StringBuilder();
for (Entry<String, String> hint : hints.entrySet()) {
Pair<Boolean, String> validationResult =
DatasetHints.validate(appCtx, hint.getKey(), hint.getValue());
if (!validationResult.first) {
errorMsgBuffer.append(StringUtils.capitalize(dataset())).append(": ")
.append(dsCreateStmt.getName().getValue()).append(" error in processing hint: ")
.append(hint.getKey()).append(" ").append(validationResult.second);
errorMsgBuffer.append(" \n");
}
}
invalidOperation = errorMsgBuffer.length() > 0;
if (invalidOperation) {
message = errorMsgBuffer.toString();
}
}
}
break;
case TRUNCATE:
namespace = getStatementNamespace(((TruncateDatasetStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("truncate", dataset(), namespace, usingDb);
}
break;
case DATASET_DROP:
namespace = getStatementNamespace(((DropDatasetStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("drop", dataset(), namespace, usingDb);
}
break;
case INDEX_DROP:
namespace = getStatementNamespace(((IndexDropStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("drop", "index", namespace, usingDb);
}
break;
case TYPE_DECL:
namespace = getStatementNamespace(((TypeDecl) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "type", namespace, usingDb);
}
break;
case TYPE_DROP:
namespace = getStatementNamespace(((TypeDropStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("drop", "type", namespace, usingDb);
}
break;
case CREATE_SYNONYM:
namespace = getStatementNamespace(((CreateSynonymStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "synonym", namespace, usingDb);
}
break;
case FUNCTION_DECL:
//TODO(DB): change to use namespace like others
FunctionDecl fnDeclStmt = (FunctionDecl) stmt;
FunctionSignature fnDeclSignature = fnDeclStmt.getSignature();
if (fnDeclSignature.getDataverseName() != null) {
namespace = new Namespace(fnDeclSignature.getDatabaseName(), fnDeclSignature.getDataverseName());
} else {
namespace = activeNamespace;
}
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("declare", "function", namespace, usingDb);
}
break;
case CREATE_FUNCTION:
//TODO(DB): check it's not System database for all cases
CreateFunctionStatement fnCreateStmt = (CreateFunctionStatement) stmt;
FunctionSignature fnCreateSignature = fnCreateStmt.getFunctionSignature();
if (fnCreateSignature.getDataverseName() != null) {
namespace =
new Namespace(fnCreateSignature.getDatabaseName(), fnCreateSignature.getDataverseName());
} else {
namespace = activeNamespace;
}
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "function", namespace, usingDb);
}
break;
case CREATE_LIBRARY:
namespace = getStatementNamespace(((CreateLibraryStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "library", namespace, usingDb);
}
break;
case CREATE_ADAPTER:
namespace = getStatementNamespace(((CreateAdapterStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "adapter", namespace, usingDb);
}
break;
case CREATE_VIEW:
namespace = getStatementNamespace(((CreateViewStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "view", namespace, usingDb);
}
break;
case CREATE_FEED:
namespace = getStatementNamespace(((CreateFeedStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "feed", namespace, usingDb);
}
break;
case CREATE_FEED_POLICY:
invalidOperation = isSystemNamespace(activeNamespace);
if (invalidOperation) {
message = formatObjectDdlMessage("create", "ingestion policy", activeNamespace, usingDb);
}
break;
case ANALYZE:
namespace = getStatementNamespace(((AnalyzeStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("analyze", dataset(), namespace, usingDb);
}
break;
case ANALYZE_DROP:
namespace = getStatementNamespace(((AnalyzeDropStatement) stmt).getNamespace(), activeNamespace);
invalidOperation = isSystemNamespace(namespace);
if (invalidOperation) {
message = formatObjectDdlMessage("analyze drop", dataset(), namespace, usingDb);
}
break;
}
if (invalidOperation) {
throw new CompilationException(ErrorCode.COMPILATION_ERROR, stmt.getSourceLocation(),
String.format(INVALID_OPERATION_MESSAGE, message));
}
}