Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * See the COPYRIGHT.txt file distributed with this work for information
   * regarding copyright ownership.  Some portions may be licensed
   * to Red Hat, Inc. under one or more contributor license agreements.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301 USA.
  */
 package org.teiid.olingo.service;
 
 import java.util.List;
 
 
 
 public class ProcedureSQLBuilder {
     private List<SQLParametersqlParameters = new ArrayList<SQLParameter>();
     private Schema teiidSchema;
     private Procedure procedure;
     private ProcedureReturn procedureReturn;
     
     static class ProcedureReturn implements ProcedureReturnType {
         private EdmType type;
         private Integer sqlType = null;
         private boolean resultSetBasedLob;
         private boolean hasResultSet;
         
         public ProcedureReturn(EdmType typeInteger sqlTypeboolean hasResultSetboolean resultsetLob) {
             this. = type;
             this. = sqlType;
             this. = resultsetLob;
             this. = hasResultSet;
         }
         
         public EdmType getReturnType() {
             return ;
         }
         
         public boolean hasResultSet() {
             return this.;
         } 
        
        public boolean hasResultSetBasedLob() {
            return ;
        }
        
        public Integer getSqlType() {
            return ;
        }        
    }
    
    interface ParameterValueProvider {
        Object getValue(EdmParameter parameterClass<?> runtimeTypethrows TeiidException;
    }    
    
    public ProcedureSQLBuilder(Schema schemaOperationRequest requestthrows TeiidException {
        this. = schema;
        
        if (request instanceof FunctionRequest) {
            FunctionRequest functionRequest = (FunctionRequest)request;
            this. = new FunctionParameterValueProvider(functionRequest.getParameters());
            visit(functionRequest.getFunction());
        }
        else {
            ActionRequest actionRequest = (ActionRequest)request;
            this. = new ActionParameterValueProvider(actionRequest.getPayload());
            visit(actionRequest.getAction());
        }        
    }
    
    public ProcedureReturn getReturn() {
        return this.;
    }
    
    public void visit(EdmOperation edmOperationthrows TeiidException {
        this. =  this..getProcedure(edmOperation.getName());
        
        if (edmOperation.getReturnType() != null) {
            visit(edmOperation.getReturnType());
        }
        
        for (String parameterName : edmOperation.getParameterNames()) {
            visit(edmOperation.getParameter(parameterName));
        }
    }
    
    private boolean hasResultSet() {
        return this..getResultSet() != null;
    }
    
    private void visit(EdmReturnType returnType) {        
        EdmType type = returnType.getType();
        Class<?> teiidType = null;
        
        if (hasResultSet()) {
            Column column = getResultSetLobColumn();
            if (column != null) {
                // this special case where single LOB column in result treated as return
                teiidType = DataTypeManager.getDataTypeClass(column.getRuntimeType());
                Integer sqlType = JDBCSQLTypeInfo.getSQLType(DataTypeManager.getDataTypeName(teiidType));
                this. = new ProcedureReturn(typesqlTypetruetrue);                
            }
            else {
                // this is complex type
                this. = new ProcedureReturn(typenulltruefalse);
            }
        }
        else {
            // must not be null
            ProcedureParameter parameter = getReturnParameter();
            teiidType = DataTypeManager.getDataTypeClass(parameter.getRuntimeType());
            Integer sqlType = JDBCSQLTypeInfo.getSQLType(DataTypeManager.getDataTypeName(teiidType));
            this. = new ProcedureReturn(typesqlTypefalsefalse);
        }
    }
    
        for (ProcedureParameter parameterthis..getParameters()) {
            if (parameter.getType().equals(..)) {
                return parameter;
            }
        }
        return null;
    }
    
    private Column getResultSetLobColumn() {
        ColumnSet<ProcedurereturnColumns = this..getResultSet();
        if (returnColumns != null) {
            List<Columncolumns = returnColumns.getColumns();
            if (columns.size() == 1 && DataTypeManager.isLOB(columns.get(0).getJavaType())) {
                return columns.get(0);
            }
        }
        return null;
    }
    private void visit(EdmParameter parameterthrows TeiidException {
        Class<?> runtimeType = resolveParameterType(this..getName(), parameter.getName());
        Integer sqlType = JDBCSQLTypeInfo.getSQLType(DataTypeManager.getDataTypeName(runtimeType));
        Object value = this..getValue(parameterruntimeType);
        this..add(new SQLParameter(parameter.getName(), 
                ODataTypeManager.convertToTeiidRuntimeType(runtimeTypevalue), sqlType));
    }
    
    public String buildProcedureSQL() {
                
        StringBuilder sql = new StringBuilder();
        
        // fully qualify the procedure name
        if (getReturn().hasResultSet()) {
            sql.append("{"); //$NON-NLS-1$
        }
        else {
            sql.append("{? = "); //$NON-NLS-1$
        }
        
        sql.append("call ").append(SQLStringVisitor.escapeSinglePart(this..getFullName())); //$NON-NLS-1$ //$NON-NLS-2$
        sql.append("("); //$NON-NLS-1$
        
        boolean first = true;
        for (SQLParameter parameter:this.) {
            if (!first) {
                sql.append(","); //$NON-NLS-1$
            }
            first = false;
            sql.append(SQLStringVisitor.escapeSinglePart(parameter.getName())).append("=>?"); //$NON-NLS-1$            
                        
        }
        sql.append(")"); //$NON-NLS-1$
        sql.append("}"); //$NON-NLS-1$
        return sql.toString();
    }
    
    public Class<?> resolveParameterType(String procedureNameString parameterName) {
        for (ProcedureParameter pp : this..getParameters()) {
            if (pp.getName().equalsIgnoreCase(parameterName)) {
                return DataTypeManager.getDataTypeClass(pp.getRuntimeType());
            }
        }
        return null;
    }
    public List<SQLParametergetSqlParameters() {
        return this.;
    }
    
    static class ActionParameterValueProvider implements ParameterValueProvider {
        private InputStream payload;
        private boolean alreadyConsumed;
        private byte[] jsonPayload;
        
        public ActionParameterValueProvider(InputStream payload) {
            this. = payload;
        }
        @Override
        public Object getValue(EdmParameter edmParameterClass<?> runtimeTypethrows TeiidException {
            if (!this.) {
                this. = true;
                if (DataTypeManager.isLOB(runtimeType)) {
                    InputStreamFactory isf = new InputStreamFactory() {
                        @Override
                        public InputStream getInputStream() throws IOException {
                            return ;
                        }
                    };
                    if (runtimeType.isAssignableFrom(XMLType.class)) {
                        return new SQLXMLImpl(isf);    
                    } else if (runtimeType.isAssignableFrom(ClobType.class)) {
                        return new ClobImpl(isf, -1);
                    } else if (runtimeType.isAssignableFrom(BlobType.class)) {
                        return new BlobImpl(isf);
                    }
                } else {
                    this. = convertToByteArray(this.);
                }
            }
            List<?> values = parseParameter(new ByteArrayInputStream((byte[]) this.), 
                    edmParameterruntimeType);
            if (edmParameter.isCollection()) {
                return values;
            } else {
                return values.get(0);
            }
        }
        
        private List<?> parseParameter(InputStream streamEdmParameter parameter
                Class<?> runtimeTypethrows TeiidException {
            try {
                ArrayList<ObjectparsedValues = new ArrayList<Object>();
                ObjectMapper objectMapper = new ObjectMapper();
                objectMapper.configure(.true);
                JsonParser parser = new JsonFactory(objectMapper).createParser(stream);
                final ObjectNode tree = parser.getCodec().readTree(parser);
                JsonNode jsonNode = tree.get(.);
                if (jsonNode != null) {
                    if (jsonNode.isArray()) {
                        ArrayNode arrayNode = (ArrayNodejsonNode;
                        Iterator<JsonNodeit = arrayNode.iterator();
                        while (it.hasNext()) {
                            String value = it.next().get(parameter.getName()).asText();
                            parsedValues.add(LiteralParser.parseLiteral(parameterruntimeTypevalue));
                        }
                    } else {
                        String value = jsonNode.asText();
                        parsedValues.add(LiteralParser.parseLiteral(parameterruntimeTypevalue));
                    }
                    tree.remove(.);
                    // if this is value there can be only one property
                    return parsedValues;
                }
                String value = tree.get(parameter.getName()).asText();
                parsedValues.add(LiteralParser.parseLiteral(parameterruntimeTypevalue));
                return parsedValues;
            } catch (JsonParseException e) {
                throw new TeiidException(e);
            } catch (JsonMappingException e) {
                throw new TeiidException(e);
            } catch (IOException e) {
                throw new TeiidException(e);
            }
        }
        
        private byte[] convertToByteArray(InputStream payloadthrows TeiidException {
            try {
                return ObjectConverterUtil.convertToByteArray(payload);
            } catch (IOException e) {
                throw new TeiidException(e);
            }
        }
    }  
    
    static class FunctionParameterValueProvider implements ParameterValueProvider {
        private List<UriParameterparameters;
        
        public FunctionParameterValueProvider(List<UriParameterparameters) {
            this. = parameters;
        }
        
        @Override
        public Object getValue(EdmParameter edmParameterClass<?> runtimeTypethrows TeiidException {                
            for (UriParameter parameter : this.) {
                if (parameter.getName().equals(edmParameter.getName())) {
                    // In Teiid one can only pass simple literal values, not complex
                    // types, no complex parsing required. And LOBs can not be inlined 
                    // for Function
                    return LiteralParser.parseLiteral(edmParameterruntimeTypeparameter.getText());
                }
            }
            return null;
        }
    }
New to GrepCode? Check out our FAQ X