Examples with TempMetadataID org.teiid.query.metadata.TempMetadataID used on opensource projects

Example 1 with TempMetadataID

use of org.teiid.query.metadata.TempMetadataID in project teiid by teiid.

the class DynamicCommandResolver method resolveCommand.

/**
 * @see org.teiid.query.resolver.CommandResolver#resolveCommand(org.teiid.query.sql.lang.Command, TempMetadataAdapter, boolean)
 */
public void resolveCommand(Command command, TempMetadataAdapter metadata, boolean resolveNullLiterals) throws QueryMetadataException, QueryResolverException, TeiidComponentException {
    DynamicCommand dynamicCmd = (DynamicCommand) command;
    Iterator columns = dynamicCmd.getAsColumns().iterator();
    Set groups = new HashSet();
    boolean resolvedColumns = false;
    // if there is no into group, just create temp metadata ids
    if (dynamicCmd.getIntoGroup() == null) {
        while (columns.hasNext()) {
            ElementSymbol column = (ElementSymbol) columns.next();
            column.setMetadataID(new TempMetadataID(column.getShortName(), column.getType()));
        }
    } else if (dynamicCmd.getIntoGroup().isTempGroupSymbol()) {
        resolvedColumns = true;
        while (columns.hasNext()) {
            ElementSymbol column = (ElementSymbol) columns.next();
            column.setGroupSymbol(new GroupSymbol(dynamicCmd.getIntoGroup().getName()));
        }
    }
    ResolverVisitor.resolveLanguageObject(dynamicCmd, groups, dynamicCmd.getExternalGroupContexts(), metadata);
    String sqlType = DataTypeManager.getDataTypeName(dynamicCmd.getSql().getType());
    String targetType = DataTypeManager.DefaultDataTypes.CLOB;
    if (!targetType.equals(sqlType) && !DataTypeManager.isImplicitConversion(sqlType, targetType)) {
        throw new QueryResolverException(QueryPlugin.Event.TEIID30100, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30100, sqlType));
    }
    dynamicCmd.setSql(ResolverUtil.convertExpression(dynamicCmd.getSql(), targetType, metadata));
    if (dynamicCmd.getUsing() != null && !dynamicCmd.getUsing().isEmpty()) {
        for (SetClause clause : dynamicCmd.getUsing().getClauses()) {
            ElementSymbol id = clause.getSymbol();
            id.setGroupSymbol(new GroupSymbol(ProcedureReservedWords.DVARS));
            id.setType(clause.getValue().getType());
            id.setMetadataID(new TempMetadataID(id.getName(), id.getType()));
        }
    }
    GroupSymbol intoSymbol = dynamicCmd.getIntoGroup();
    if (intoSymbol != null) {
        if (!intoSymbol.isImplicitTempGroupSymbol()) {
            ResolverUtil.resolveGroup(intoSymbol, metadata);
            if (!resolvedColumns) {
                // must be a temp table from a higher scope
                for (ElementSymbol column : (List<ElementSymbol>) dynamicCmd.getAsColumns()) {
                    column.setGroupSymbol(dynamicCmd.getIntoGroup().clone());
                }
            }
        } else {
            List symbols = dynamicCmd.getAsColumns();
            ResolverUtil.resolveImplicitTempGroup(metadata, intoSymbol, symbols);
        }
    }
}

Example 2 with TempMetadataID

use of org.teiid.query.metadata.TempMetadataID in project teiid by teiid.

the class ExecResolver method findCommandMetadata.

/**
 * @see org.teiid.query.resolver.CommandResolver#findCommandMetadata(org.teiid.query.sql.lang.Command,
 * org.teiid.query.metadata.QueryMetadataInterface)
 */
private void findCommandMetadata(Command command, TempMetadataStore discoveredMetadata, QueryMetadataInterface metadata) throws QueryMetadataException, QueryResolverException, TeiidComponentException {
    StoredProcedure storedProcedureCommand = (StoredProcedure) command;
    StoredProcedureInfo storedProcedureInfo = null;
    try {
        storedProcedureInfo = metadata.getStoredProcedureInfoForProcedure(storedProcedureCommand.getProcedureName());
    } catch (QueryMetadataException e) {
        // $NON-NLS-1$
        String[] parts = storedProcedureCommand.getProcedureName().split("\\.", 2);
        if (parts.length > 1 && parts[0].equalsIgnoreCase(metadata.getVirtualDatabaseName())) {
            try {
                storedProcedureInfo = metadata.getStoredProcedureInfoForProcedure(parts[1]);
                storedProcedureCommand.setProcedureName(parts[1]);
            } catch (QueryMetadataException e1) {
            }
        }
        if (storedProcedureInfo == null) {
            throw e;
        }
    }
    storedProcedureCommand.setUpdateCount(storedProcedureInfo.getUpdateCount());
    storedProcedureCommand.setModelID(storedProcedureInfo.getModelID());
    storedProcedureCommand.setProcedureID(storedProcedureInfo.getProcedureID());
    storedProcedureCommand.setProcedureCallableName(storedProcedureInfo.getProcedureCallableName());
    // Get old parameters as they may have expressions set on them - collect
    // those expressions to copy later into the resolved parameters
    Collection<SPParameter> oldParams = storedProcedureCommand.getParameters();
    boolean namedParameters = storedProcedureCommand.displayNamedParameters();
    // of relying on all default values of all optional parameters.
    if (oldParams.size() == 0 || (oldParams.size() == 1 && storedProcedureCommand.isCalledWithReturn())) {
        storedProcedureCommand.setDisplayNamedParameters(true);
        namedParameters = true;
    }
    // Cache original input parameter expressions.  Depending on whether
    // the procedure was parsed with named or unnamed parameters, the keys
    // for this map will either be the String names of the parameters or
    // the Integer indices, as entered in the user query
    Map<Integer, Expression> positionalExpressions = new TreeMap<Integer, Expression>();
    Map<String, Expression> namedExpressions = new TreeMap<String, Expression>(String.CASE_INSENSITIVE_ORDER);
    int adjustIndex = 0;
    for (SPParameter param : oldParams) {
        if (param.getExpression() == null) {
            if (param.getParameterType() == SPParameter.RESULT_SET) {
                // If this was already resolved, just pretend the result set param doesn't exist
                adjustIndex--;
            }
            continue;
        }
        if (namedParameters && param.getParameterType() != SPParameter.RETURN_VALUE) {
            if (namedExpressions.put(param.getParameterSymbol().getShortName(), param.getExpression()) != null) {
                throw new QueryResolverException(QueryPlugin.Event.TEIID30138, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30138, param.getName()));
            }
        } else {
            positionalExpressions.put(param.getIndex() + adjustIndex, param.getExpression());
        }
    }
    storedProcedureCommand.clearParameters();
    int origInputs = positionalExpressions.size() + namedExpressions.size();
    /*
         * Take the values set from the stored procedure implementation, and match up with the
         * types of parameter it is from the metadata and then reset the newly joined parameters
         * into the stored procedure command.  If it is a result set get those columns and place
         * them into the stored procedure command as well.
         */
    List<SPParameter> metadataParams = storedProcedureInfo.getParameters();
    List<SPParameter> clonedMetadataParams = new ArrayList<SPParameter>(metadataParams.size());
    int inputParams = 0;
    int optionalParams = 0;
    int outParams = 0;
    boolean hasReturnValue = false;
    boolean optional = false;
    boolean varargs = false;
    for (int i = 0; i < metadataParams.size(); i++) {
        SPParameter metadataParameter = metadataParams.get(i);
        if ((metadataParameter.getParameterType() == ParameterInfo.IN) || (metadataParameter.getParameterType() == ParameterInfo.INOUT)) {
            if (ResolverUtil.hasDefault(metadataParameter.getMetadataID(), metadata) || metadataParameter.isVarArg()) {
                optional = true;
                optionalParams++;
            } else {
                inputParams++;
                if (optional) {
                    optional = false;
                    inputParams += optionalParams;
                    optionalParams = 0;
                }
            }
            if (metadataParameter.isVarArg()) {
                varargs = true;
            }
        } else if (metadataParameter.getParameterType() == ParameterInfo.OUT) {
            outParams++;
        /*
            	 * TODO: it would consistent to do the following, but it is a breaking change for procedures that have intermixed out params with in.
            	 * we may need to revisit this later
            	 */
        // optional = true;
        // optionalParams++;
        } else if (metadataParameter.getParameterType() == ParameterInfo.RETURN_VALUE) {
            hasReturnValue = true;
        }
        SPParameter clonedParam = (SPParameter) metadataParameter.clone();
        clonedMetadataParams.add(clonedParam);
        storedProcedureCommand.setParameter(clonedParam);
    }
    if (storedProcedureCommand.isCalledWithReturn() && !hasReturnValue) {
        throw new QueryResolverException(QueryPlugin.Event.TEIID30139, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30139, storedProcedureCommand.getGroup()));
    }
    if (!namedParameters && (inputParams > positionalExpressions.size())) {
        // $NON-NLS-1$ //$NON-NLS-2$
        throw new QueryResolverException(QueryPlugin.Event.TEIID30140, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30140, inputParams, inputParams + optionalParams + (varargs ? "+" : ""), origInputs, storedProcedureCommand.getGroup()));
    }
    // Walk through the resolved parameters and set the expressions from the
    // input parameters
    int exprIndex = 1;
    HashSet<String> expected = new HashSet<String>();
    if (storedProcedureCommand.isCalledWithReturn() && hasReturnValue) {
        for (SPParameter param : clonedMetadataParams) {
            if (param.getParameterType() == SPParameter.RETURN_VALUE) {
                Expression expr = positionalExpressions.remove(exprIndex++);
                param.setExpression(expr);
                break;
            }
        }
    }
    for (SPParameter param : clonedMetadataParams) {
        if (param.getParameterType() == SPParameter.RESULT_SET || param.getParameterType() == SPParameter.RETURN_VALUE) {
            continue;
        }
        if (namedParameters) {
            String nameKey = param.getParameterSymbol().getShortName();
            Expression expr = namedExpressions.remove(nameKey);
            // With named parameters, have to check on optional params and default values
            if (expr == null) {
                if (param.getParameterType() != ParameterInfo.OUT) {
                    param.setUsingDefault(true);
                    expected.add(nameKey);
                    if (!param.isVarArg()) {
                        expr = ResolverUtil.getDefault(param.getParameterSymbol(), metadata);
                    } else {
                        // zero length array
                        List<Expression> exprs = new ArrayList<Expression>(0);
                        Array array = new Array(exprs);
                        array.setImplicit(true);
                        array.setType(param.getClassType());
                        expr = array;
                    }
                }
            }
            param.setExpression(expr);
        } else {
            Expression expr = positionalExpressions.remove(exprIndex++);
            if (param.getParameterType() == SPParameter.OUT) {
                if (expr != null) {
                    boolean isRef = expr instanceof Reference;
                    if (!isRef || exprIndex <= inputParams + 1) {
                        // for backwards compatibility, this should be treated instead as an input
                        exprIndex--;
                        positionalExpressions.put(exprIndex, expr);
                    } else if (isRef) {
                        // mimics the hack that was in PreparedStatementRequest.
                        Reference ref = (Reference) expr;
                        // may be an out
                        ref.setOptional(true);
                    /*
	                		 * Note that there is a corner case here with out parameters intermixed with optional parameters
	                		 * there's not a good way around this.
	                		 */
                    }
                }
                continue;
            }
            if (expr == null) {
                if (!param.isVarArg()) {
                    expr = ResolverUtil.getDefault(param.getParameterSymbol(), metadata);
                }
                param.setUsingDefault(true);
            }
            if (param.isVarArg()) {
                List<Expression> exprs = new ArrayList<Expression>(positionalExpressions.size() + 1);
                if (expr != null) {
                    exprs.add(expr);
                }
                exprs.addAll(positionalExpressions.values());
                positionalExpressions.clear();
                Array array = new Array(exprs);
                array.setImplicit(true);
                array.setType(param.getClassType());
                expr = array;
            }
            param.setExpression(expr);
        }
    }
    // Check for leftovers, i.e. params entered by user w/ wrong/unknown names
    if (!namedExpressions.isEmpty()) {
        throw new QueryResolverException(QueryPlugin.Event.TEIID30141, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30141, namedExpressions.keySet(), expected));
    }
    if (!positionalExpressions.isEmpty()) {
        throw new QueryResolverException(QueryPlugin.Event.TEIID31113, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31113, positionalExpressions.size(), origInputs, storedProcedureCommand.getGroup().toString()));
    }
    // Create temporary metadata that defines a group based on either the stored proc
    // name or the stored query name - this will be used later during planning
    String procName = storedProcedureCommand.getProcedureName();
    List tempElements = storedProcedureCommand.getProjectedSymbols();
    boolean isVirtual = storedProcedureInfo.getQueryPlan() != null;
    discoveredMetadata.addTempGroup(procName, tempElements, isVirtual);
    // Resolve tempElements against new metadata
    GroupSymbol procGroup = new GroupSymbol(storedProcedureInfo.getProcedureCallableName());
    procGroup.setProcedure(true);
    TempMetadataID tid = discoveredMetadata.getTempGroupID(procName);
    tid.setOriginalMetadataID(storedProcedureCommand.getProcedureID());
    procGroup.setMetadataID(tid);
    storedProcedureCommand.setGroup(procGroup);
}

Example 3 with TempMetadataID

use of org.teiid.query.metadata.TempMetadataID in project teiid by teiid.

the class SimpleQueryResolver method resolveWith.

static void resolveWith(TempMetadataAdapter metadata, QueryCommand query) throws QueryResolverException, TeiidComponentException {
    if (query.getWith() == null) {
        return;
    }
    LinkedHashSet<GroupSymbol> discoveredGroups = new LinkedHashSet<GroupSymbol>();
    for (WithQueryCommand obj : query.getWith()) {
        QueryCommand queryExpression = obj.getCommand();
        QueryResolver.setChildMetadata(queryExpression, query);
        QueryCommand recursive = null;
        try {
            QueryResolver.resolveCommand(queryExpression, metadata.getMetadata(), false);
        } catch (QueryResolverException e) {
            if (!(queryExpression instanceof SetQuery)) {
                throw e;
            }
            SetQuery setQuery = (SetQuery) queryExpression;
            // valid form must be a union with nothing above
            if (setQuery.getOperation() != Operation.UNION || setQuery.getLimit() != null || setQuery.getOrderBy() != null || setQuery.getOption() != null) {
                throw e;
            }
            QueryResolver.resolveCommand(setQuery.getLeftQuery(), metadata.getMetadata(), false);
            recursive = setQuery.getRightQuery();
        }
        if (!discoveredGroups.add(obj.getGroupSymbol())) {
            throw new QueryResolverException(QueryPlugin.Event.TEIID30101, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30101, obj.getGroupSymbol()));
        }
        List<? extends Expression> projectedSymbols = obj.getCommand().getProjectedSymbols();
        if (obj.getColumns() != null && !obj.getColumns().isEmpty()) {
            if (obj.getColumns().size() != projectedSymbols.size()) {
                throw new QueryResolverException(QueryPlugin.Event.TEIID30102, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30102, obj.getGroupSymbol()));
            }
            Iterator<ElementSymbol> iter = obj.getColumns().iterator();
            for (Expression singleElementSymbol : projectedSymbols) {
                ElementSymbol es = iter.next();
                es.setType(singleElementSymbol.getType());
            }
            projectedSymbols = obj.getColumns();
        }
        TempMetadataID id = ResolverUtil.addTempGroup(metadata, obj.getGroupSymbol(), projectedSymbols, true);
        obj.getGroupSymbol().setMetadataID(metadata.getMetadataStore().getTempGroupID(obj.getGroupSymbol().getName()));
        obj.getGroupSymbol().setIsTempTable(true);
        List<GroupSymbol> groups = Collections.singletonList(obj.getGroupSymbol());
        if (obj.getColumns() != null && !obj.getColumns().isEmpty()) {
            for (Expression singleElementSymbol : projectedSymbols) {
                ResolverVisitor.resolveLanguageObject(singleElementSymbol, groups, metadata);
            }
        }
        if (obj.getColumns() != null && !obj.getColumns().isEmpty()) {
            Iterator<ElementSymbol> iter = obj.getColumns().iterator();
            for (TempMetadataID colid : id.getElements()) {
                ElementSymbol es = iter.next();
                es.setMetadataID(colid);
                es.setGroupSymbol(obj.getGroupSymbol());
            }
        }
        if (recursive != null) {
            QueryResolver.setChildMetadata(recursive, query);
            QueryResolver.resolveCommand(recursive, metadata.getMetadata(), false);
            new SetQueryResolver().resolveSetQuery(metadata, false, (SetQuery) queryExpression, ((SetQuery) queryExpression).getLeftQuery(), recursive);
            obj.setRecursive(true);
        }
    }
}

Example 4 with TempMetadataID

use of org.teiid.query.metadata.TempMetadataID in project teiid by teiid.

the class TempTableResolver method resolveCommand.

/**
 * @see org.teiid.query.resolver.CommandResolver#resolveCommand(org.teiid.query.sql.lang.Command, org.teiid.query.metadata.TempMetadataAdapter, boolean)
 */
public void resolveCommand(Command command, TempMetadataAdapter metadata, boolean resolveNullLiterals) throws QueryMetadataException, QueryResolverException, TeiidComponentException {
    if (command.getType() == Command.TYPE_CREATE) {
        Create create = (Create) command;
        GroupSymbol group = create.getTable();
        // assuming that all temp table creates are local, the user must use a local name
        if (group.getName().indexOf(Symbol.SEPARATOR) != -1) {
            throw new QueryResolverException(QueryPlugin.Event.TEIID30117, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30117, group.getName()));
        }
        // this will only check non-temp groups
        Collection exitsingGroups = metadata.getMetadata().getGroupsForPartialName(group.getName());
        if (!exitsingGroups.isEmpty()) {
            throw new QueryResolverException(QueryPlugin.Event.TEIID30118, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30118, group.getName()));
        }
        if (metadata.getMetadata().hasProcedure(group.getName())) {
            throw new QueryResolverException(QueryPlugin.Event.TEIID30118, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30118, group.getName()));
        }
        // now we will be more specific for temp groups
        TempMetadataID id = metadata.getMetadataStore().getTempGroupID(group.getName());
        if (id != null && !metadata.isTemporaryTable(id)) {
            throw new QueryResolverException(QueryPlugin.Event.TEIID30118, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30118, group.getName()));
        }
        // if we get here then either the group does not exist or has already been defined as a temp table
        // if it has been defined as a temp table, that's ok we'll use this as the new definition and throw an
        // exception at runtime if the user has not dropped the previous table yet
        TempMetadataID tempTable = ResolverUtil.addTempTable(metadata, group, create.getColumnSymbols());
        ResolverUtil.resolveGroup(create.getTable(), metadata);
        Set<GroupSymbol> groups = new HashSet<GroupSymbol>();
        groups.add(create.getTable());
        ResolverVisitor.resolveLanguageObject(command, groups, metadata);
        addAdditionalMetadata(create, tempTable);
        tempTable.setOriginalMetadataID(create.getTableMetadata());
        if (create.getOn() != null) {
            Object mid = null;
            try {
                mid = metadata.getModelID(create.getOn());
            } catch (QueryMetadataException e) {
                throw new QueryResolverException(QueryPlugin.Event.TEIID31134, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31134, create.getOn()));
            }
            if (mid != null && (metadata.isVirtualModel(mid) || !(mid instanceof Schema))) {
                throw new QueryResolverException(QueryPlugin.Event.TEIID31135, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31135, create.getOn()));
            }
            create.getTableMetadata().setParent((Schema) mid);
            tempTable.getTableData().setModel(mid);
        }
    } else if (command.getType() == Command.TYPE_DROP) {
        ResolverUtil.resolveGroup(((Drop) command).getTable(), metadata);
    }
}

Example 5 with TempMetadataID

use of org.teiid.query.metadata.TempMetadataID in project teiid by teiid.

the class TempTableResolver method addAdditionalMetadata.

public static void addAdditionalMetadata(Create create, TempMetadataID tempTable) {
    if (!create.getPrimaryKey().isEmpty()) {
        ArrayList<TempMetadataID> primaryKey = new ArrayList<TempMetadataID>(create.getPrimaryKey().size());
        for (ElementSymbol symbol : create.getPrimaryKey()) {
            Object mid = symbol.getMetadataID();
            if (mid instanceof TempMetadataID) {
                primaryKey.add((TempMetadataID) mid);
            } else if (mid instanceof Column) {
                // TODO: this breaks our normal metadata usage
                primaryKey.add(tempTable.getElements().get(((Column) mid).getPosition() - 1));
            }
        }
        tempTable.setPrimaryKey(primaryKey);
    }
    for (int i = 0; i < create.getColumns().size(); i++) {
        Column column = create.getColumns().get(i);
        TempMetadataID tid = tempTable.getElements().get(i);
        if (column.isAutoIncremented()) {
            tid.setAutoIncrement(true);
        }
        if (column.getNullType() == NullType.No_Nulls) {
            tid.setNotNull(true);
        }
    }
}