This is an automated email from the ASF dual-hosted git repository. dlych pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/asterixdb.git
commit b317f37e2618a8571c8d20ec23f091900dd04d85 Merge: 820e6f0 95fa33c Author: Dmitry Lychagin <[email protected]> AuthorDate: Fri Oct 30 11:35:16 2020 -0700 Merge commit '95fa33c' Change-Id: I756837cde80d423cd068924c248dc36856345c10 .../asterix/app/translator/QueryTranslator.java | 20 ++++++++ .../invalid-dataset-name.1.ddl.sqlpp | 29 +++++++++++ .../invalid-dataset-name.2.ddl.sqlpp | 29 +++++++++++ .../invalid-dataset-name.3.ddl.sqlpp | 20 ++++++++ .../invalid-dataverse-name.1.ddl.sqlpp | 24 ++++++++++ .../invalid-dataverse-name.2.ddl.sqlpp | 24 ++++++++++ .../invalid-feed-name.1.ddl.sqlpp | 42 ++++++++++++++++ .../invalid-feed-name.2.ddl.sqlpp | 42 ++++++++++++++++ .../invalid-feed-name.3.ddl.sqlpp | 20 ++++++++ .../invalid-feed-policy-name.1.ddl.sqlpp | 30 ++++++++++++ .../invalid-feed-policy-name.2.ddl.sqlpp | 30 ++++++++++++ .../invalid-feed-policy-name.3.ddl.sqlpp | 20 ++++++++ .../invalid-index-name.1.ddl.sqlpp | 31 ++++++++++++ .../invalid-index-name.2.ddl.sqlpp | 31 ++++++++++++ .../invalid-index-name.3.ddl.sqlpp | 20 ++++++++ .../invalid-nodegroup-name.1.ddl.sqlpp | 24 ++++++++++ .../invalid-nodegroup-name.2.ddl.sqlpp | 24 ++++++++++ .../invalid-type-name.1.ddl.sqlpp | 31 ++++++++++++ .../invalid-type-name.2.ddl.sqlpp | 31 ++++++++++++ .../invalid-type-name.3.ddl.sqlpp | 20 ++++++++ .../invalid-udf-name/invalid-udf-name.1.ddl.sqlpp | 31 ++++++++++++ .../invalid-udf-name/invalid-udf-name.2.ddl.sqlpp | 31 ++++++++++++ .../invalid-udf-name/invalid-udf-name.3.ddl.sqlpp | 20 ++++++++ .../test/resources/runtimets/testsuite_sqlpp.xml | 56 ++++++++++++++++++++++ .../asterix/common/exceptions/ErrorCode.java | 4 +- .../src/main/resources/asx_errormsg/en.properties | 3 +- 26 files changed, 684 insertions(+), 3 deletions(-) diff --cc asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java index 5339d94,d29a5f5..ec43870 --- a/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java +++ b/asterixdb/asterix-app/src/main/java/org/apache/asterix/app/translator/QueryTranslator.java @@@ -515,10 -491,17 +515,13 @@@ public class QueryTranslator extends Ab protected void handleCreateDataverseStatement(MetadataProvider metadataProvider, Statement stmt, IRequestParameters requestParameters) throws Exception { CreateDataverseStatement stmtCreateDataverse = (CreateDataverseStatement) stmt; - SourceLocation sourceLoc = stmtCreateDataverse.getSourceLocation(); - String dvName = stmtCreateDataverse.getDataverseName().getValue(); - validateDatabaseObjectName(dvName, sourceLoc); - MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); - metadataProvider.setMetadataTxnContext(mdTxnCtx); - lockManager.acquireDataverseReadLock(metadataProvider.getLocks(), dvName); + DataverseName dvName = stmtCreateDataverse.getDataverseName(); ++ for (String dvNamePart : dvName.getParts()) { ++ validateDatabaseObjectName(dvNamePart, stmtCreateDataverse.getSourceLocation()); ++ } + lockUtil.createDataverseBegin(lockManager, metadataProvider.getLocks(), dvName); try { - doCreateDataverseStatement(mdTxnCtx, metadataProvider, stmtCreateDataverse); - } catch (Exception e) { - abort(e, e, mdTxnCtx); - throw e; + doCreateDataverseStatement(metadataProvider, stmtCreateDataverse, requestParameters); } finally { metadataProvider.getLocks().unlock(); } @@@ -589,13 -565,16 +592,14 @@@ } public void handleCreateDatasetStatement(MetadataProvider metadataProvider, Statement stmt, - IHyracksClientConnection hcc, IRequestParameters requestParameters) throws CompilationException, Exception { - MutableObject<ProgressState> progress = new MutableObject<>(ProgressState.NO_PROGRESS); + IHyracksClientConnection hcc, IRequestParameters requestParameters) throws Exception { DatasetDecl dd = (DatasetDecl) stmt; - SourceLocation sourceLoc = dd.getSourceLocation(); - String dataverseName = getActiveDataverse(dd.getDataverse()); + DataverseName dataverseName = getActiveDataverseName(dd.getDataverse()); String datasetName = dd.getName().getValue(); - validateDatabaseObjectName(datasetName, sourceLoc); - DatasetType dsType = dd.getDatasetType(); ++ validateDatabaseObjectName(datasetName, stmt.getSourceLocation()); TypeExpression itemTypeExpr = dd.getItemType(); - String itemTypeDataverseName, itemTypeName; + DataverseName itemTypeDataverseName; + String itemTypeName; boolean itemTypeAnonymous; switch (itemTypeExpr.getTypeKind()) { case TYPEREFERENCE: @@@ -961,23 -910,21 +965,25 @@@ public void handleCreateIndexStatement(MetadataProvider metadataProvider, Statement stmt, IHyracksClientConnection hcc, IRequestParameters requestParameters) throws Exception { CreateIndexStatement stmtCreateIndex = (CreateIndexStatement) stmt; - SourceLocation sourceLoc = stmtCreateIndex.getSourceLocation(); - String dataverseName = getActiveDataverse(stmtCreateIndex.getDataverseName()); + DataverseName dataverseName = getActiveDataverseName(stmtCreateIndex.getDataverseName()); String datasetName = stmtCreateIndex.getDatasetName().getValue(); + String indexName = stmtCreateIndex.getIndexName().getValue(); - validateDatabaseObjectName(indexName, sourceLoc); - IndexType indexType = stmtCreateIndex.getIndexType(); - List<Integer> keySourceIndicators = stmtCreateIndex.getFieldSourceIndicators(); ++ validateDatabaseObjectName(indexName, stmt.getSourceLocation()); + lockUtil.createIndexBegin(lockManager, metadataProvider.getLocks(), dataverseName, datasetName); + try { + doCreateIndex(metadataProvider, stmtCreateIndex, dataverseName, datasetName, hcc, requestParameters); + } finally { + metadataProvider.getLocks().unlock(); + } + } + + protected void doCreateIndex(MetadataProvider metadataProvider, CreateIndexStatement stmtCreateIndex, + DataverseName dataverseName, String datasetName, IHyracksClientConnection hcc, + IRequestParameters requestParameters) throws Exception { + SourceLocation sourceLoc = stmtCreateIndex.getSourceLocation(); MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); + boolean bActiveTxn = true; metadataProvider.setMetadataTxnContext(mdTxnCtx); - String datasetFullyQualifiedName = dataverseName + "." + datasetName; - boolean isSecondaryPrimary = stmtCreateIndex.getFieldExprs().isEmpty(); - Dataset ds; - Index index; - MetadataLockUtil.createIndexBegin(lockManager, metadataProvider.getLocks(), dataverseName, - datasetFullyQualifiedName); try { // Check if the dataverse exists Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverseName); @@@ -1386,11 -1346,13 +1392,12 @@@ protected void handleCreateTypeStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception { TypeDecl stmtCreateType = (TypeDecl) stmt; SourceLocation sourceLoc = stmtCreateType.getSourceLocation(); - String dataverseName = getActiveDataverse(stmtCreateType.getDataverseName()); + DataverseName dataverseName = getActiveDataverseName(stmtCreateType.getDataverseName()); String typeName = stmtCreateType.getIdent().getValue(); + validateDatabaseObjectName(typeName, sourceLoc); MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); metadataProvider.setMetadataTxnContext(mdTxnCtx); - MetadataLockUtil.createTypeBegin(lockManager, metadataProvider.getLocks(), dataverseName, - dataverseName + "." + typeName); + lockUtil.createTypeBegin(lockManager, metadataProvider.getLocks(), dataverseName, typeName); try { Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverseName); if (dv == null) { @@@ -1967,378 -1933,44 +1974,379 @@@ } } - protected void handleCreateFunctionStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception { + protected void handleDeclareFunctionStatement(Statement stmt) { + FunctionDecl fds = (FunctionDecl) stmt; + FunctionSignature signature = fds.getSignature(); + signature.setDataverseName(getActiveDataverseName(signature.getDataverseName())); + declaredFunctions.add(fds); + } + + public void handleCreateFunctionStatement(MetadataProvider metadataProvider, Statement stmt, + IStatementRewriter stmtRewriter) throws Exception { CreateFunctionStatement cfs = (CreateFunctionStatement) stmt; - SourceLocation sourceLoc = cfs.getSourceLocation(); FunctionSignature signature = cfs.getFunctionSignature(); - validateDatabaseObjectName(signature.getName(), sourceLoc); - String dataverse = getActiveDataverseName(signature.getNamespace()); - signature.setNamespace(dataverse); ++ validateDatabaseObjectName(signature.getName(), stmt.getSourceLocation()); + DataverseName dataverseName = getActiveDataverseName(signature.getDataverseName()); + signature.setDataverseName(dataverseName); + DataverseName libraryDataverseName = null; + String libraryName = cfs.getLibraryName(); + if (libraryName != null) { + libraryDataverseName = cfs.getLibraryDataverseName(); + if (libraryDataverseName == null) { + libraryDataverseName = dataverseName; + } + } + + lockUtil.createFunctionBegin(lockManager, metadataProvider.getLocks(), dataverseName, signature.getName(), + libraryDataverseName, libraryName); + try { + doCreateFunction(metadataProvider, cfs, signature, stmtRewriter); + } finally { + metadataProvider.getLocks().unlock(); + metadataProvider.setDefaultDataverse(activeDataverse); + } + } + protected void doCreateFunction(MetadataProvider metadataProvider, CreateFunctionStatement cfs, + FunctionSignature functionSignature, IStatementRewriter stmtRewriter) throws Exception { + DataverseName dataverseName = functionSignature.getDataverseName(); + SourceLocation sourceLoc = cfs.getSourceLocation(); MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); metadataProvider.setMetadataTxnContext(mdTxnCtx); - MetadataLockUtil.functionStatementBegin(lockManager, metadataProvider.getLocks(), dataverse, - dataverse + "." + signature.getName()); try { - Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverse); + Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverseName); if (dv == null) { - throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverse); + throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName); + } + List<TypeSignature> existingInlineTypes; + Function existingFunction = MetadataManager.INSTANCE.getFunction(mdTxnCtx, functionSignature); + if (existingFunction != null) { + if (cfs.getReplaceIfExists()) { + if (cfs.getIfNotExists()) { + throw new CompilationException(ErrorCode.PARSE_ERROR, cfs.getSourceLocation(), "IF NOT EXISTS"); + } + } else if (cfs.getIfNotExists()) { + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + return; + } else { + throw new CompilationException(ErrorCode.FUNCTION_EXISTS, cfs.getSourceLocation(), + functionSignature.toString(false)); + } + existingInlineTypes = TypeUtil.getFunctionInlineTypes(existingFunction); + } else { + existingInlineTypes = Collections.emptyList(); + } + + Map<TypeSignature, Datatype> newInlineTypes; + Function function; + if (cfs.isExternal()) { + List<Pair<VarIdentifier, TypeExpression>> paramList = cfs.getParameters(); + int paramCount = paramList.size(); + List<String> paramNames = new ArrayList<>(paramCount); + List<TypeSignature> paramTypes = new ArrayList<>(paramCount); + LinkedHashSet<TypeSignature> depTypes = new LinkedHashSet<>(); + newInlineTypes = new HashMap<>(); + + for (int i = 0; i < paramCount; i++) { + Pair<VarIdentifier, TypeExpression> paramPair = paramList.get(i); + TypeSignature paramTypeSignature; + TypeSignature paramDepTypeSignature; + Datatype paramInlineTypeEntity; + TypeExpression paramTypeExpr = paramPair.getSecond(); + if (paramTypeExpr != null) { + Triple<TypeSignature, TypeSignature, Datatype> paramTypeInfo = translateFunctionParameterType( + functionSignature, i, paramTypeExpr, sourceLoc, metadataProvider, mdTxnCtx); + paramTypeSignature = paramTypeInfo.first; + paramDepTypeSignature = paramTypeInfo.second; + paramInlineTypeEntity = paramTypeInfo.third; + } else { + paramTypeSignature = null; // == any + paramDepTypeSignature = null; + paramInlineTypeEntity = null; + } + paramTypes.add(paramTypeSignature); // null == any + if (paramDepTypeSignature != null) { + depTypes.add(paramDepTypeSignature); + } + if (paramInlineTypeEntity != null) { + newInlineTypes.put(paramTypeSignature, paramInlineTypeEntity); + } + VarIdentifier paramName = paramPair.getFirst(); + paramNames.add(stmtRewriter.toFunctionParameterName(paramName)); + } + + TypeSignature returnTypeSignature; + TypeSignature returnDepTypeSignature; + Datatype returnInlineTypeEntity; + TypeExpression returnTypeExpr = cfs.getReturnType(); + if (returnTypeExpr != null) { + Triple<TypeSignature, TypeSignature, Datatype> returnTypeInfo = translateFunctionParameterType( + functionSignature, -1, returnTypeExpr, sourceLoc, metadataProvider, mdTxnCtx); + returnTypeSignature = returnTypeInfo.first; + returnDepTypeSignature = returnTypeInfo.second; + returnInlineTypeEntity = returnTypeInfo.third; + } else { + returnTypeSignature = null; // == any + returnDepTypeSignature = null; + returnInlineTypeEntity = null; + } + if (returnDepTypeSignature != null) { + depTypes.add(returnDepTypeSignature); + } + if (returnInlineTypeEntity != null) { + newInlineTypes.put(returnTypeSignature, returnInlineTypeEntity); + } + + DataverseName libraryDataverseName = cfs.getLibraryDataverseName(); + if (libraryDataverseName == null) { + libraryDataverseName = dataverseName; + } + String libraryName = cfs.getLibraryName(); + Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDataverseName, libraryName); + if (library == null) { + throw new CompilationException(ErrorCode.UNKNOWN_LIBRARY, sourceLoc, libraryName); + } + + ExternalFunctionLanguage language = + ExternalFunctionCompilerUtil.getExternalFunctionLanguage(library.getLanguage()); + List<String> externalIdentifier = cfs.getExternalIdentifier(); + ExternalFunctionCompilerUtil.validateExternalIdentifier(externalIdentifier, language, + cfs.getSourceLocation()); + List<List<Triple<DataverseName, String, String>>> dependencies = + FunctionUtil.getExternalFunctionDependencies(depTypes); + + function = new Function(functionSignature, paramNames, paramTypes, returnTypeSignature, null, + FunctionKind.SCALAR.toString(), library.getLanguage(), libraryDataverseName, libraryName, + externalIdentifier, cfs.getNullCall(), cfs.getDeterministic(), cfs.getResources(), + dependencies); + } else { + List<Pair<VarIdentifier, TypeExpression>> paramList = cfs.getParameters(); + int paramCount = paramList.size(); + List<VarIdentifier> paramVars = new ArrayList<>(paramCount); + List<String> paramNames = new ArrayList<>(paramCount); + for (Pair<VarIdentifier, TypeExpression> paramPair : paramList) { + VarIdentifier paramName = paramPair.getFirst(); + paramVars.add(paramName); + paramNames.add(stmtRewriter.toFunctionParameterName(paramName)); + if (paramPair.getSecond() != null) { + throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc, + paramName.toString()); + } + } + + //Check whether the function is use-able + metadataProvider.setDefaultDataverse(dv); + Query wrappedQuery = new Query(false); + wrappedQuery.setSourceLocation(sourceLoc); + wrappedQuery.setBody(cfs.getFunctionBodyExpression()); + wrappedQuery.setTopLevel(false); + apiFramework.reWriteQuery(declaredFunctions, metadataProvider, wrappedQuery, sessionOutput, false, + paramVars, warningCollector); + List<List<Triple<DataverseName, String, String>>> dependencies = FunctionUtil.getFunctionDependencies( + rewriterFactory.createQueryRewriter(), cfs.getFunctionBodyExpression(), metadataProvider); + + newInlineTypes = Collections.emptyMap(); + function = new Function(functionSignature, paramNames, null, null, cfs.getFunctionBody(), + FunctionKind.SCALAR.toString(), compilationProvider.getParserFactory().getLanguage(), null, + null, null, null, null, null, dependencies); + } + + if (existingFunction == null) { + // add new function and its inline types + for (Datatype newInlineType : newInlineTypes.values()) { + MetadataManager.INSTANCE.addDatatype(mdTxnCtx, newInlineType); + } + MetadataManager.INSTANCE.addFunction(mdTxnCtx, function); + } else { + // replace existing function and its inline types + for (TypeSignature existingInlineType : existingInlineTypes) { + Datatype newInlineType = + newInlineTypes.isEmpty() ? null : newInlineTypes.remove(existingInlineType); + if (newInlineType == null) { + MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, existingInlineType.getDataverseName(), + existingInlineType.getName()); + } else { + MetadataManager.INSTANCE.updateDatatype(mdTxnCtx, newInlineType); + } + } + for (Datatype inlineType : newInlineTypes.values()) { + MetadataManager.INSTANCE.addDatatype(mdTxnCtx, inlineType); + } + MetadataManager.INSTANCE.updateFunction(mdTxnCtx, function); + } + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Installed function: " + functionSignature); + } + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + } catch (Exception e) { + abort(e, e, mdTxnCtx); + throw e; + } + } + + private Triple<TypeSignature, TypeSignature, Datatype> translateFunctionParameterType( + FunctionSignature functionSignature, int paramIdx, TypeExpression paramTypeExpr, SourceLocation sourceLoc, + MetadataProvider metadataProvider, MetadataTransactionContext mdTxnCtx) throws AlgebricksException { + TypeSignature paramTypeSignature, depTypeSignature; + Datatype paramInlineTypeEntity = null; + switch (paramTypeExpr.getTypeKind()) { + case TYPEREFERENCE: + TypeReferenceExpression paramTypeRefExpr = (TypeReferenceExpression) paramTypeExpr; + String paramTypeName = paramTypeRefExpr.getIdent().second.getValue(); + BuiltinType builtinType = BuiltinTypeMap.getBuiltinType(paramTypeName); + if (builtinType != null) { + // built-in type + paramTypeSignature = new TypeSignature(builtinType); + depTypeSignature = null; + } else { + // user-defined type + DataverseName paramTypeDataverseName = paramTypeRefExpr.getIdent().first; + if (paramTypeDataverseName == null) { + paramTypeDataverseName = functionSignature.getDataverseName(); + } + Datatype paramTypeEntity = metadataProvider.findTypeEntity(paramTypeDataverseName, paramTypeName); + if (paramTypeEntity == null || paramTypeEntity.getIsAnonymous()) { + throw new CompilationException(ErrorCode.UNKNOWN_TYPE, sourceLoc, paramTypeName); + } + paramTypeSignature = depTypeSignature = new TypeSignature(paramTypeDataverseName, paramTypeName); + } + break; + case ORDEREDLIST: + case UNORDEREDLIST: + DataverseName paramTypeDataverseName = functionSignature.getDataverseName(); + paramTypeName = TypeUtil.createFunctionParameterTypeName(functionSignature.getName(), + functionSignature.getArity(), paramIdx); + IAType paramType = translateType(paramTypeDataverseName, paramTypeName, paramTypeExpr, mdTxnCtx); + paramTypeSignature = new TypeSignature(paramTypeDataverseName, paramTypeName); + depTypeSignature = + FunctionUtil.getTypeDependencyFromFunctionParameter(paramTypeExpr, paramTypeDataverseName); + paramInlineTypeEntity = new Datatype(paramTypeDataverseName, paramTypeName, paramType, true); + break; + default: + throw new CompilationException(ErrorCode.COMPILATION_ILLEGAL_STATE, sourceLoc); + } + + return new Triple<>(paramTypeSignature, depTypeSignature, paramInlineTypeEntity); + } + + protected void handleFunctionDropStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception { + FunctionDropStatement stmtDropFunction = (FunctionDropStatement) stmt; + FunctionSignature signature = stmtDropFunction.getFunctionSignature(); + DataverseName dataverseName = getActiveDataverseName(signature.getDataverseName()); + signature.setDataverseName(dataverseName); + lockUtil.dropFunctionBegin(lockManager, metadataProvider.getLocks(), dataverseName, signature.getName()); + try { + doDropFunction(metadataProvider, stmtDropFunction, signature); + } finally { + metadataProvider.getLocks().unlock(); + } + } + + protected boolean doDropFunction(MetadataProvider metadataProvider, FunctionDropStatement stmtDropFunction, + FunctionSignature signature) throws Exception { + DataverseName dataverseName = signature.getDataverseName(); + SourceLocation sourceLoc = stmtDropFunction.getSourceLocation(); + MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); + metadataProvider.setMetadataTxnContext(mdTxnCtx); + try { + Dataverse dataverse = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverseName); + if (dataverse == null) { + if (stmtDropFunction.getIfExists()) { + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + return false; + } else { + throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName); + } + } + Function function = MetadataManager.INSTANCE.getFunction(mdTxnCtx, signature); + if (function == null) { + if (stmtDropFunction.getIfExists()) { + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + return false; + } else { + throw new CompilationException(ErrorCode.UNKNOWN_FUNCTION, sourceLoc, signature.toString()); + } } - //Check whether the function is use-able - metadataProvider.setDefaultDataverse(dv); - Query wrappedQuery = new Query(false); - wrappedQuery.setSourceLocation(sourceLoc); - wrappedQuery.setBody(cfs.getFunctionBodyExpression()); - wrappedQuery.setTopLevel(false); - List<VarIdentifier> paramVars = new ArrayList<>(); - for (String v : cfs.getParamList()) { - paramVars.add(new VarIdentifier(v)); + List<TypeSignature> inlineTypes = TypeUtil.getFunctionInlineTypes(function); + + MetadataManager.INSTANCE.dropFunction(mdTxnCtx, signature); + for (TypeSignature inlineType : inlineTypes) { + MetadataManager.INSTANCE.dropDatatype(mdTxnCtx, inlineType.getDataverseName(), inlineType.getName()); + } + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + return true; + } catch (Exception e) { + abort(e, e, mdTxnCtx); + throw e; + } + } + + protected void handleCreateAdapterStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception { + CreateAdapterStatement cas = (CreateAdapterStatement) stmt; + DataverseName dataverseName = getActiveDataverseName(cas.getDataverseName()); + DataverseName libraryDataverseName = cas.getLibraryDataverseName(); + if (libraryDataverseName == null) { + libraryDataverseName = dataverseName; + } + String libraryName = cas.getLibraryName(); + lockUtil.createAdapterBegin(lockManager, metadataProvider.getLocks(), dataverseName, cas.getAdapterName(), + libraryDataverseName, libraryName); + try { + doCreateAdapter(metadataProvider, cas); + } finally { + metadataProvider.getLocks().unlock(); + } + } + + protected void doCreateAdapter(MetadataProvider metadataProvider, CreateAdapterStatement cas) throws Exception { + SourceLocation sourceLoc = cas.getSourceLocation(); + MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); + metadataProvider.setMetadataTxnContext(mdTxnCtx); + try { + DataverseName dataverseName = getActiveDataverseName(cas.getDataverseName()); + Dataverse dv = MetadataManager.INSTANCE.getDataverse(mdTxnCtx, dataverseName); + if (dv == null) { + throw new CompilationException(ErrorCode.UNKNOWN_DATAVERSE, sourceLoc, dataverseName); + } + String adapterName = cas.getAdapterName(); + DatasourceAdapter adapter = MetadataManager.INSTANCE.getAdapter(mdTxnCtx, dataverseName, adapterName); + if (adapter != null) { + if (cas.getIfNotExists()) { + MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); + return; + } + throw new CompilationException(ErrorCode.ADAPTER_EXISTS, sourceLoc, adapterName); } - apiFramework.reWriteQuery(declaredFunctions, metadataProvider, wrappedQuery, sessionOutput, false, - paramVars, warningCollector); - List<List<List<String>>> dependencies = FunctionUtil.getFunctionDependencies( - rewriterFactory.createQueryRewriter(), cfs.getFunctionBodyExpression(), metadataProvider); + DataverseName libraryDataverseName = cas.getLibraryDataverseName(); + if (libraryDataverseName == null) { + libraryDataverseName = dataverseName; + } + String libraryName = cas.getLibraryName(); + Library library = MetadataManager.INSTANCE.getLibrary(mdTxnCtx, libraryDataverseName, libraryName); + if (library == null) { + throw new CompilationException(ErrorCode.UNKNOWN_LIBRARY, sourceLoc, libraryName); + } + // Add adapters + ExternalFunctionLanguage language = + ExternalFunctionCompilerUtil.getExternalFunctionLanguage(library.getLanguage()); + List<String> externalIdentifier = cas.getExternalIdentifier(); + ExternalFunctionCompilerUtil.validateExternalIdentifier(externalIdentifier, language, + cas.getSourceLocation()); - Function function = new Function(signature, cfs.getParamList(), Function.RETURNTYPE_VOID, - cfs.getFunctionBody(), getFunctionLanguage(), FunctionKind.SCALAR.toString(), dependencies); - MetadataManager.INSTANCE.addFunction(mdTxnCtx, function); + if (language != ExternalFunctionLanguage.JAVA) { + throw new CompilationException(ErrorCode.UNSUPPORTED_ADAPTER_LANGUAGE, cas.getSourceLocation(), + language.name()); + } + String adapterFactoryClass = externalIdentifier.get(0); + adapter = new DatasourceAdapter(new AdapterIdentifier(dataverseName, adapterName), + IDataSourceAdapter.AdapterType.EXTERNAL, adapterFactoryClass, libraryDataverseName, libraryName); + MetadataManager.INSTANCE.addAdapter(mdTxnCtx, adapter); + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Installed adapter: " + adapterName); + } MetadataManager.INSTANCE.commitTransaction(mdTxnCtx); } catch (Exception e) { abort(e, e, mdTxnCtx); @@@ -2874,11 -2239,13 +2882,12 @@@ protected void handleCreateFeedStatement(MetadataProvider metadataProvider, Statement stmt) throws Exception { CreateFeedStatement cfs = (CreateFeedStatement) stmt; SourceLocation sourceLoc = cfs.getSourceLocation(); - String dataverseName = getActiveDataverse(cfs.getDataverseName()); + DataverseName dataverseName = getActiveDataverseName(cfs.getDataverseName()); String feedName = cfs.getFeedName().getValue(); + validateDatabaseObjectName(feedName, sourceLoc); MetadataTransactionContext mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); metadataProvider.setMetadataTxnContext(mdTxnCtx); - MetadataLockUtil.createFeedBegin(lockManager, metadataProvider.getLocks(), dataverseName, - dataverseName + "." + feedName); + lockUtil.createFeedBegin(lockManager, metadataProvider.getLocks(), dataverseName, feedName); try { Feed feed = MetadataManager.INSTANCE.getFeed(metadataProvider.getMetadataTxnContext(), dataverseName, feedName); @@@ -2912,9 -2281,11 +2921,10 @@@ MetadataTransactionContext mdTxnCtx = null; CreateFeedPolicyStatement cfps = (CreateFeedPolicyStatement) stmt; SourceLocation sourceLoc = cfps.getSourceLocation(); - dataverse = getActiveDataverse(null); - policy = cfps.getPolicyName(); - validateDatabaseObjectName(policy, sourceLoc); - MetadataLockUtil.createFeedPolicyBegin(lockManager, metadataProvider.getLocks(), dataverse, - dataverse + "." + policy); + DataverseName dataverseName = getActiveDataverseName(null); + String policyName = cfps.getPolicyName(); ++ validateDatabaseObjectName(policyName, sourceLoc); + lockUtil.createFeedPolicyBegin(lockManager, metadataProvider.getLocks(), dataverseName, policyName); try { mdTxnCtx = MetadataManager.INSTANCE.beginTransaction(); metadataProvider.setMetadataTxnContext(mdTxnCtx); diff --cc asterixdb/asterix-common/src/main/java/org/apache/asterix/common/exceptions/ErrorCode.java index 3aae2e1,21c3416..38150f5 --- a/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/exceptions/ErrorCode.java +++ b/asterixdb/asterix-common/src/main/java/org/apache/asterix/common/exceptions/ErrorCode.java @@@ -203,23 -203,8 +203,23 @@@ public class ErrorCode public static final int INVALID_PROPERTY_FORMAT = 1112; public static final int INVALID_REGEX_PATTERN = 1113; public static final int EXTERNAL_SOURCE_CONFIGURATION_RETURNED_NO_FILES = 1114; - public static final int SYNONYM_EXISTS = 1115; + public static final int INVALID_DATABASE_OBJECT_NAME = 1115; - + public static final int UNKNOWN_SYNONYM = 1116; + public static final int UNKNOWN_LIBRARY = 1117; + public static final int COMPILATION_GROUPING_SETS_OVERFLOW = 1118; + public static final int COMPILATION_GROUPING_OPERATION_INVALID_ARG = 1119; + public static final int COMPILATION_UNEXPECTED_ALIAS = 1120; + public static final int COMPILATION_ILLEGAL_USE_OF_FILTER_CLAUSE = 1121; + public static final int COMPILATION_BAD_FUNCTION_DEFINITION = 1122; + public static final int FUNCTION_EXISTS = 1123; + public static final int ADAPTER_EXISTS = 1124; + public static final int UNKNOWN_ADAPTER = 1125; + public static final int INVALID_EXTERNAL_IDENTIFIER_SIZE = 1126; + public static final int UNSUPPORTED_ADAPTER_LANGUAGE = 1127; + public static final int INCONSISTENT_FILTER_INDICATOR = 1128; + public static final int UNSUPPORTED_GBY_OBY_SELECT_COMBO = 1129; + public static final int ILLEGAL_RIGHT_OUTER_JOIN = 1130; - ++ public static final int SYNONYM_EXISTS = 1131; // Feed errors public static final int DATAFLOW_ILLEGAL_STATE = 3001; public static final int UTIL_DATAFLOW_UTILS_TUPLE_TOO_LARGE = 3002; diff --cc asterixdb/asterix-common/src/main/resources/asx_errormsg/en.properties index 40caeb8,5012c7a..a02c50b --- a/asterixdb/asterix-common/src/main/resources/asx_errormsg/en.properties +++ b/asterixdb/asterix-common/src/main/resources/asx_errormsg/en.properties @@@ -200,22 -198,7 +200,23 @@@ 1112 = Invalid format for property \"%1$s\" 1113 = Invalid pattern %1$s 1114 = The provided external dataset configuration returned no files from the external source - 1115 = A synonym with this name %1$s already exists + 1115 = Invalid name for a database object: \"%1$s\" +1116 = Cannot find synonym with name %1$s +1117 = Unknown library %1$s +1118 = Too many grouping sets in group by clause: %1$s. Maximum allowed: %2$s. +1119 = Invalid argument to grouping() function +1120 = Unexpected alias: %1$s +1121 = Illegal use of aggregate FILTER clause +1122 = Error compiling function %1$s. %2$s +1123 = A function with this name %1$s already exists +1124 = An adapter with this name %1$s already exists +1125 = Cannot find adapter with name %1$s +1126 = Invalid number of elements in external identifier. Expected %1$s elements for %2$s language +1127 = Unsupported adapter language: %1$s +1128 = Filter field is not defined properly +1129 = Cannot compile SELECT variable.* with GROUP BY GROUPING SETS/ROLLUP/CUBE followed by ORDER BY/LIMIT +1130 = Illegal use of RIGHT OUTER JOIN ++1131 = A synonym with this name %1$s already exists # Feed Errors 3001 = Illegal state.
