0001: /*
0002: * The contents of this file are subject to the terms of the Common Development
0003: * and Distribution License (the License). You may not use this file except in
0004: * compliance with the License.
0005: *
0006: * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
0007: * or http://www.netbeans.org/cddl.txt.
0008: *
0009: * When distributing Covered Code, include this CDDL Header Notice in each file
0010: * and include the License file at http://www.netbeans.org/cddl.txt.
0011: * If applicable, add the following below the CDDL Header, with the fields
0012: * enclosed by brackets [] replaced by your own identifying information:
0013: * "Portions Copyrighted [year] [name of copyright owner]"
0014: *
0015: * The Original Software is NetBeans. The Initial Developer of the Original
0016: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
0017: * Microsystems, Inc. All Rights Reserved.
0018: */
0019:
0020: /*
0021: * Sun Public License Notice
0022: *
0023: * The contents of this file are subject to the Sun Public License
0024: * Version 1.0 (the "License"). You may not use this file except in
0025: * compliance with the License. A copy of the License is available at
0026: * http://www.sun.com/
0027: *
0028: * The Original Code is NetBeans. The Initial Developer of the Original
0029: * Code is Sun Microsystems, Inc. Portions Copyright 1997-2005 Sun
0030: * Microsystems, Inc. All Rights Reserved.
0031: */
0032:
0033: package org.netbeans.modules.sql.project.anttasks;
0034:
0035: import org.netbeans.modules.sql.project.dbmodel.DBMetaData;
0036: import org.netbeans.modules.sql.project.dbmodel.PrepStmt;
0037: import org.netbeans.modules.sql.project.dbmodel.ResultSetColumn;
0038: import org.netbeans.modules.sql.project.dbmodel.ResultSetColumns;
0039: import org.netbeans.modules.sql.project.dbmodel.Parameter;
0040: import org.netbeans.modules.sql.project.dbmodel.Procedure;
0041:
0042: import org.netbeans.api.db.explorer.DatabaseConnection;
0043:
0044: import java.util.logging.Logger;
0045: import java.util.logging.Level;
0046: import java.util.List;
0047: import java.util.Iterator;
0048: import java.util.HashMap;
0049: import java.util.Map;
0050: import java.util.StringTokenizer;
0051:
0052: import java.net.URL;
0053: import java.net.URI;
0054: import java.io.Writer;
0055: import java.io.FileWriter;
0056: import java.io.IOException;
0057: import java.io.PrintWriter;
0058: import java.io.File;
0059: import java.io.BufferedReader;
0060: import java.io.FileReader;
0061: import java.sql.Connection;
0062: import javax.wsdl.extensions.soap.SOAPAddress;
0063: import javax.wsdl.extensions.soap.SOAPBinding;
0064:
0065: import javax.wsdl.factory.WSDLFactory;
0066: import javax.wsdl.xml.WSDLWriter;
0067: import javax.wsdl.xml.WSDLReader;
0068: import javax.wsdl.Definition;
0069: import javax.wsdl.WSDLException;
0070: import javax.wsdl.Types;
0071: import javax.wsdl.PortType;
0072: import javax.wsdl.Service;
0073: import javax.wsdl.Port;
0074: import javax.wsdl.Message;
0075: import javax.wsdl.Part;
0076: import javax.wsdl.Operation;
0077: import javax.wsdl.Input;
0078: import javax.wsdl.Output;
0079: import javax.wsdl.Binding;
0080: import javax.wsdl.BindingOperation;
0081: import javax.wsdl.BindingInput;
0082: import javax.wsdl.BindingOutput;
0083: import javax.wsdl.extensions.schema.Schema;
0084: import javax.wsdl.extensions.UnknownExtensibilityElement;
0085: import javax.xml.namespace.QName;
0086: import javax.xml.parsers.DocumentBuilderFactory;
0087: import javax.xml.parsers.ParserConfigurationException;
0088: import javax.xml.transform.TransformerFactory;
0089: import javax.xml.transform.Transformer;
0090: import javax.xml.transform.OutputKeys;
0091: import javax.xml.transform.dom.DOMSource;
0092: import javax.xml.transform.stream.StreamResult;
0093:
0094: import org.w3c.dom.Element;
0095: import org.w3c.dom.NodeList;
0096: import org.w3c.dom.Node;
0097: import org.w3c.dom.Document;
0098: import org.xml.sax.SAXException;
0099:
0100: public class WSDLGenerator {
0101:
0102: public static HashMap builtInTypes = new HashMap();
0103: private static Logger logger = Logger.getLogger(WSDLGenerator.class
0104: .getName());
0105: private static WSDLFactory factory;
0106: private static DocumentBuilderFactory docBuilderfactory;
0107:
0108: private Definition def;
0109: private DBMetaData dbmeta;
0110: private String sqlFileName;
0111: private List sqlFileList = null;
0112: private String schema;
0113: private String wsdlFileLocation;
0114: private String engineFileName;
0115: private Document doc;
0116: private String STATEMENT_TYPE = null;
0117: private String wsdlFileName = null;
0118: private boolean wsdlFileExsits = false;
0119: private Connection conn;
0120: private DatabaseConnection dbConn;
0121: private static final String SELECT_STATEMENT = "SELECT";
0122: private static final String INSERT_STATEMENT = "INSERT";
0123: private static final String UPDATE_STATEMENT = "UPDATE";
0124: private static final String DELETE_STATEMENT = "DELETE";
0125: private static final String DDL_STATEMENT_CREATE = "CREATE";
0126: private static final String DDL_STATEMENT_ALTER = "ALTER";
0127: private static final String DDL_STATEMENT_DROP = "DROP";
0128: private static final String TRUNCATE_STATEMENT = "TRUNCATE";
0129: private static final String PROC_STATEMENT = "EXEC";
0130:
0131: static {
0132: builtInTypes.put("byte[]", "xsd:base64Binary");
0133: builtInTypes.put("boolean", "xsd:boolean");
0134: builtInTypes.put("byte", "xsd:byte");
0135: builtInTypes.put("java.util.Calendar", "xsd:dateTime");
0136: builtInTypes.put("java.math.BigDecimal", "xsd:decimal");
0137: builtInTypes.put("double", "xsd:double");
0138: builtInTypes.put("float", "xsd:float");
0139: builtInTypes.put("byte[]", "xsd:hexBinary");
0140: builtInTypes.put("int", "xsd:int");
0141: builtInTypes.put("java.math.BigInteger", "xsd:integer");
0142: builtInTypes.put("long", "xsd:long");
0143: builtInTypes.put("javax.xml.namespace.QName", "xsd:QName");
0144: builtInTypes.put("short", "xsd:short");
0145: builtInTypes.put("java.lang.String", "xsd:string");
0146: builtInTypes.put("java.sql.Time", "xsd:string");
0147: builtInTypes.put("java.sql.Timestamp", "xsd:string");
0148: builtInTypes.put("java.sql.Date", "xsd:string");
0149:
0150: // temporary for demo
0151: builtInTypes.put("java.sql.Blob", "xsd:string");
0152: builtInTypes.put("java.sql.Clob", "xsd:string");
0153: //added by abey for Procedure with parameter of type RefCursor
0154: builtInTypes.put("java.sql.ResultSet", "xsd:ResultSet");
0155:
0156: }
0157:
0158: static {
0159: initFactory();
0160: }
0161:
0162: /**
0163: * Constructor
0164: * @param dbmeta
0165: * @param sqlFile
0166: * @param wsdlFileLocation
0167: */
0168: public WSDLGenerator(DBMetaData dbmeta, String sqlFile,
0169: String wsdlFileLocation, String engineFileName) {
0170: this .dbmeta = dbmeta;
0171: this .sqlFileName = sqlFile;
0172: this .wsdlFileLocation = wsdlFileLocation;
0173: this .engineFileName = engineFileName.substring(0,
0174: engineFileName.indexOf(".xml"));
0175: }
0176:
0177: public WSDLGenerator(Connection conn, List sqlFiles,
0178: String wsdlFileName, String wsdlFileLocation,
0179: String engineFileName) {
0180: this .conn = conn;
0181: this .sqlFileList = sqlFiles;
0182: this .wsdlFileLocation = wsdlFileLocation;
0183: this .wsdlFileName = wsdlFileName;
0184: this .engineFileName = engineFileName.substring(0,
0185: engineFileName.indexOf(".xml"));
0186: }
0187:
0188: /**
0189: * initialize the WSDLFactory
0190: */
0191: private static void initFactory() {
0192: if (factory == null) {
0193: try {
0194: factory = WSDLFactory.newInstance();
0195: docBuilderfactory = DocumentBuilderFactory
0196: .newInstance();
0197: } catch (WSDLException wsdle) {
0198: logger.log(Level.WARNING, wsdle.getMessage(), wsdle);
0199: }
0200: }
0201: }
0202:
0203: /**
0204: * reads an sqlpro wsdl template file and genarates the javax.wsdl.Definition
0205: *
0206: * @return Definition
0207: * @throws WSDLException
0208: */
0209: private Definition getWsdlTemplate() throws WSDLException,
0210: ParserConfigurationException, SAXException, IOException {
0211: Definition def = null;
0212: try {
0213: URL u = WSDLGenerator.class
0214: .getResource("sqlpro.wsdl.template");
0215: if (u != null) {
0216: String wsdlURI = u.getFile().indexOf(".jar") > 0 ? "jar:"
0217: + u.getFile()
0218: : u.getFile();
0219: def = readWSDLFile(wsdlURI);
0220:
0221: } else {
0222: logger.log(Level.WARNING,
0223: "Unable to locate the wsdl template");
0224: }
0225: } catch (WSDLException e) {
0226: logger.log(Level.SEVERE, e.getMessage(), e);
0227: throw e;
0228: } catch (ParserConfigurationException e) {
0229: logger.log(Level.SEVERE, e.getMessage(), e);
0230: throw e;
0231: } catch (SAXException e) {
0232: logger.log(Level.SEVERE, e.getMessage(), e);
0233: throw e;
0234: } catch (IOException e) {
0235: logger.log(Level.SEVERE, e.getMessage(), e);
0236: throw e;
0237: }
0238: return def;
0239: }
0240:
0241: private Definition readWSDLFile(String wsdlURI)
0242: throws SAXException, IOException,
0243: ParserConfigurationException, WSDLException {
0244: WSDLReader reader = factory.newWSDLReader();
0245: Definition def;
0246: docBuilderfactory.setNamespaceAware(true);
0247: docBuilderfactory.setValidating(false);
0248: doc = docBuilderfactory.newDocumentBuilder().parse(wsdlURI);
0249: def = reader.readWSDL(wsdlURI, doc);
0250: return def;
0251: }
0252:
0253: public Definition generateWSDL() throws Exception {
0254: try {
0255: //wsdlFileName = wsdlFileLocation + "/" + sqlFileName + ".wsdl";
0256: if (new File(wsdlFileLocation + File.separator
0257: + wsdlFileName + ".wsdl").exists()) {
0258: wsdlFileExsits = true;
0259: this .def = loadExistingWSDLFile(wsdlFileName);
0260: } else {
0261: this .def = getWsdlTemplate();
0262: }
0263: modifyWSDL();
0264: writeWsdl();
0265: } catch (Exception e) {
0266: logger.log(Level.SEVERE, e.getMessage(), e);
0267: throw e;
0268: }
0269: return def;
0270: }
0271:
0272: private Definition loadExistingWSDLFile(String wsdlFileName) {
0273: try {
0274: URI f = new File(wsdlFileLocation + File.separator
0275: + wsdlFileName + ".wsdl").toURI();
0276: Definition def = readWSDLFile(f.getPath());
0277: return def;
0278: } catch (Exception mfe) {
0279: logger.log(Level.SEVERE,
0280: "Unable to load existing wsdl file " + wsdlFileName
0281: + " Reason: " + mfe.getLocalizedMessage());
0282: }
0283: return null;
0284: }
0285:
0286: /**
0287: * modify the wsdl template
0288: */
0289: private void modifyWSDL() throws Exception {
0290: try {
0291: modifyName();
0292:
0293: if (sqlFileList != null) {
0294: for (int i = 0; i < sqlFileList.size(); i++) {
0295: File f = (File) sqlFileList.get(i);
0296: sqlFileName = f.getName().trim().substring(0,
0297: f.getName().indexOf(".sql"));
0298: modifyMessageTypes(f);
0299: createMessages();
0300: PortType pt = createPortType();
0301: Binding binding = createBinding(pt);
0302: modifyServices(binding);
0303: }
0304: modifyPartnerLink();
0305: }
0306: } catch (Exception e) {
0307: logger.log(Level.SEVERE, e.getLocalizedMessage());
0308: throw e;
0309: }
0310: }
0311:
0312: private void modifyName() {
0313: QName q = def.getQName();
0314: q = new QName(q.getNamespaceURI(), wsdlFileName);
0315: def.setQName(q);
0316: }
0317:
0318: private void modifyMessageTypes(File sqlFile) throws Exception {
0319: try {
0320: Element currRequest = null;
0321: Element currResponse = null;
0322:
0323: //Read sql file.
0324: BufferedReader reader = new BufferedReader(new FileReader(
0325: sqlFile));
0326: String line = null;
0327: StringBuffer sqlText = new StringBuffer();
0328: while ((line = reader.readLine()) != null) {
0329: if (sqlText.length() != 0) {
0330: sqlText.append("\n");
0331: }
0332: sqlText.append(line);
0333: }
0334: dbmeta = new DBMetaData(conn, sqlText.toString());
0335: logger.log(Level.INFO, "SQL Statement is:["
0336: + dbmeta.getSQLText() + "]");
0337: parseSQLStatement(sqlText.toString());
0338: Types types = def.getTypes();
0339:
0340: if (null != types) {
0341: List schemaList = types.getExtensibilityElements();
0342: for (Iterator iterator1 = schemaList.iterator(); iterator1
0343: .hasNext();) {
0344: Object o = iterator1.next();
0345: if (o instanceof Schema) {
0346: Schema schemaType = (Schema) o;
0347: Element e = schemaType.getElement();
0348: currRequest = getElementByName(e, sqlFileName
0349: + "Request");
0350: if (currRequest == null) {
0351: currRequest = createElementWithComplexType(sqlFileName
0352: + "Request");
0353: }
0354: if (STATEMENT_TYPE != null) {
0355: if (STATEMENT_TYPE
0356: .equalsIgnoreCase(SELECT_STATEMENT)) {
0357: currResponse = getElementByName(e,
0358: sqlFileName + "Response");
0359: if (currResponse == null) {
0360: currResponse = createElementWithComplexType(sqlFileName
0361: + "Response");
0362: }
0363: generateSelectSchemaElements(
0364: currRequest, currResponse);
0365: } else if (STATEMENT_TYPE
0366: .equalsIgnoreCase(INSERT_STATEMENT)) {
0367: currResponse = getElementByName(e,
0368: sqlFileName + "Response");
0369: removeSchemaElements(currRequest,
0370: currResponse);
0371: if (currResponse == null) {
0372: currResponse = createElement(
0373: "numRowsEffected",
0374: "xsd:int");
0375: }
0376: currResponse = getElementByName(e,
0377: "numRowsEffected");
0378: if (currResponse == null) {
0379: currResponse = createElement(
0380: "numRowsEffected",
0381: "xsd:int");
0382: }
0383: generateInsertSchemaElements(
0384: currRequest, currResponse);
0385: } else if (STATEMENT_TYPE
0386: .equalsIgnoreCase(UPDATE_STATEMENT)) {
0387: currResponse = getElementByName(e,
0388: sqlFileName + "Response");
0389: removeSchemaElements(currRequest,
0390: currResponse);
0391: if (currResponse == null) {
0392: currResponse = createElement(
0393: "numRowsEffected",
0394: "xsd:int");
0395: }
0396: currResponse = getElementByName(e,
0397: "numRowsEffected");
0398: if (currResponse == null) {
0399: currResponse = createElement(
0400: "numRowsEffected",
0401: "xsd:int");
0402: }
0403: generateInsertSchemaElements(
0404: currRequest, currResponse);
0405: } else if (STATEMENT_TYPE
0406: .equalsIgnoreCase(DELETE_STATEMENT)) {
0407: currResponse = getElementByName(e,
0408: sqlFileName + "Response");
0409: removeSchemaElements(currRequest,
0410: currResponse);
0411: if (currResponse == null) {
0412: currResponse = createElement(
0413: "numRowsEffected",
0414: "xsd:int");
0415: }
0416: currResponse = getElementByName(e,
0417: "numRowsEffected");
0418: if (currResponse == null) {
0419: currResponse = createElement(
0420: "numRowsEffected",
0421: "xsd:int");
0422: }
0423: generateInsertSchemaElements(
0424: currRequest, currResponse);
0425: } else if (STATEMENT_TYPE
0426: .equalsIgnoreCase(DDL_STATEMENT_CREATE)) {
0427: currResponse = getElementByName(e,
0428: sqlFileName + "Response");
0429: removeSchemaElements(currRequest,
0430: currResponse);
0431: if (currResponse == null) {
0432: currResponse = createElement(
0433: "numRowsEffected",
0434: "xsd:int");
0435: }
0436: currResponse = getElementByName(e,
0437: "numRowsEffected");
0438: if (currResponse == null) {
0439: currResponse = createElement(
0440: "numRowsEffected",
0441: "xsd:int");
0442: }
0443: generateCreateSchemaElements(
0444: currRequest, currResponse);
0445: } else if (STATEMENT_TYPE
0446: .equalsIgnoreCase(DDL_STATEMENT_ALTER)) {
0447: currResponse = getElementByName(e,
0448: sqlFileName + "Response");
0449: removeSchemaElements(currRequest,
0450: currResponse);
0451: if (currResponse == null) {
0452: currResponse = createElement(
0453: "numRowsEffected",
0454: "xsd:int");
0455: }
0456: currResponse = getElementByName(e,
0457: "numRowsEffected");
0458: if (currResponse == null) {
0459: currResponse = createElement(
0460: "numRowsEffected",
0461: "xsd:int");
0462: }
0463: generateAlterSchemaElements(
0464: currRequest, currResponse);
0465: } else if (STATEMENT_TYPE
0466: .equalsIgnoreCase(DDL_STATEMENT_DROP)) {
0467: currResponse = getElementByName(e,
0468: sqlFileName + "Response");
0469: removeSchemaElements(currRequest,
0470: currResponse);
0471: if (currResponse == null) {
0472: currResponse = createElement(
0473: "numRowsEffected",
0474: "xsd:int");
0475: }
0476: currResponse = getElementByName(e,
0477: "numRowsEffected");
0478: if (currResponse == null) {
0479: currResponse = createElement(
0480: "numRowsEffected",
0481: "xsd:int");
0482: }
0483: generateDropSchemaElements(currRequest,
0484: currResponse);
0485: } else if (STATEMENT_TYPE
0486: .equalsIgnoreCase(TRUNCATE_STATEMENT)) {
0487: currResponse = getElementByName(e,
0488: sqlFileName + "Response");
0489: removeSchemaElements(currRequest,
0490: currResponse);
0491: if (currResponse == null) {
0492: currResponse = createElement(
0493: "numRowsEffected",
0494: "xsd:int");
0495: }
0496: currResponse = getElementByName(e,
0497: "numRowsEffected");
0498: if (currResponse == null) {
0499: currResponse = createElement(
0500: "numRowsEffected",
0501: "xsd:int");
0502: }
0503: generateTruncateSchemaElements(
0504: currRequest, currResponse);
0505: } else if (STATEMENT_TYPE
0506: .equalsIgnoreCase(PROC_STATEMENT)) {
0507: currResponse = getElementByName(e,
0508: sqlFileName + "Response");
0509: if (currResponse == null) {
0510: currResponse = createElementWithComplexType(sqlFileName
0511: + "Response");
0512: }
0513: generateProcSchemaElements(currRequest,
0514: currResponse);
0515: }
0516: e.appendChild(currRequest);
0517: e.appendChild(currResponse);
0518: } else {
0519: throw new Exception(
0520: "Unsupported SQL Statement entered: "
0521: + sqlText);
0522: }
0523:
0524: } else if (o instanceof UnknownExtensibilityElement) {
0525: //
0526: }
0527: }
0528: }
0529:
0530: } catch (Exception e) {
0531: logger.log(Level.SEVERE, e.getLocalizedMessage(), e);
0532: throw e;
0533: }
0534:
0535: }
0536:
0537: private void createMessages() {
0538: QName responseQName = null;
0539: QName partQName = null;
0540: Message m = def.createMessage();
0541: QName qname = new QName(def.getTargetNamespace(), sqlFileName
0542: + "Request");
0543: Part p = def.createPart();
0544: p.setName(sqlFileName + "RequestPart");
0545: p.setElementName(qname);
0546: m.addPart(p);
0547: m.setQName(qname);
0548: m.setUndefined(false);
0549: def.addMessage(m);
0550: Message mResponse = def.createMessage();
0551: Part p2 = def.createPart();
0552:
0553: if (STATEMENT_TYPE.equalsIgnoreCase(SELECT_STATEMENT)
0554: || STATEMENT_TYPE.equalsIgnoreCase(PROC_STATEMENT)) {
0555: partQName = new QName(def.getTargetNamespace(), sqlFileName
0556: + "Response");
0557: } else if (STATEMENT_TYPE.equalsIgnoreCase(INSERT_STATEMENT)
0558: || STATEMENT_TYPE.equalsIgnoreCase(UPDATE_STATEMENT)
0559: || STATEMENT_TYPE.equalsIgnoreCase(DELETE_STATEMENT)
0560: || STATEMENT_TYPE
0561: .equalsIgnoreCase(DDL_STATEMENT_CREATE)
0562: || STATEMENT_TYPE.equalsIgnoreCase(DDL_STATEMENT_ALTER)
0563: || STATEMENT_TYPE.equalsIgnoreCase(DDL_STATEMENT_DROP)
0564: || STATEMENT_TYPE.equalsIgnoreCase(TRUNCATE_STATEMENT)) {
0565: partQName = new QName(def.getTargetNamespace(),
0566: "numRowsEffected");
0567: }
0568: p2.setName(sqlFileName + "ResponsePart");
0569: p2.setElementName(partQName);
0570: mResponse.addPart(p2);
0571: responseQName = new QName(def.getTargetNamespace(), sqlFileName
0572: + "Response");
0573: mResponse.setQName(responseQName);
0574: mResponse.setUndefined(false);
0575: def.addMessage(mResponse);
0576:
0577: }
0578:
0579: /**
0580: * this sets the portType name according to the given engine file
0581: */
0582: private PortType createPortType() {
0583: QName qn = new QName(def.getTargetNamespace(), wsdlFileName
0584: + "_sqlsePortType");
0585: PortType pt = def.getPortType(qn);
0586:
0587: if (pt == null) {
0588: pt = def.createPortType();
0589: pt.setQName(qn);
0590: pt.setUndefined(false);
0591: def.addPortType(pt);
0592: }
0593: createPortTypeOperations(pt);
0594: return pt;
0595: }
0596:
0597: private void createPortTypeOperations(PortType pt) {
0598: Operation op = pt.getOperation(sqlFileName, sqlFileName
0599: + "Request", sqlFileName + "Response");
0600: if (op == null) {
0601: op = def.createOperation();
0602: op.setName(sqlFileName);
0603: Input input = def.createInput();
0604: Output output = def.createOutput();
0605: input.setMessage(getMessageByName(sqlFileName + "Request"));
0606: input.setName(sqlFileName + "Request");
0607: output
0608: .setMessage(getMessageByName(sqlFileName
0609: + "Response"));
0610: output.setName(sqlFileName + "Response");
0611: op.setInput(input);
0612: op.setOutput(output);
0613: op.setUndefined(false);
0614: pt.addOperation(op);
0615: }
0616: }
0617:
0618: private Binding createBinding(PortType pt) {
0619: QName qname = new QName(def.getTargetNamespace(), wsdlFileName
0620: + "Binding");
0621: Binding binding = def.getBinding(qname);
0622: if (binding == null) {
0623: binding = def.createBinding();
0624: binding.setQName(qname);
0625: binding.setUndefined(false);
0626: binding.setPortType(pt);
0627: def.addBinding(binding);
0628: } else {
0629: PortType pt2 = binding.getPortType();
0630: if (pt2.equals(pt)) {
0631: BindingOperation bindingOp = binding
0632: .getBindingOperation(sqlFileName, sqlFileName
0633: + "Request", sqlFileName + "Response");
0634: if (bindingOp != null) {
0635: return binding;
0636: }
0637: } else {
0638: binding.setPortType(pt2);
0639: pt = pt2;
0640: }
0641: }
0642:
0643: BindingOperation bo = def.createBindingOperation();
0644: bo.setName(sqlFileName);
0645: if (pt != null) {
0646: Operation op = pt.getOperation(sqlFileName, sqlFileName
0647: + "Request", sqlFileName + "Response");
0648: if (op != null) {
0649: bo.setOperation(op);
0650: BindingInput binput = def.createBindingInput();
0651: binput.setName(sqlFileName + "Request");
0652: bo.setBindingInput(binput);
0653: BindingOutput boutput = def.createBindingOutput();
0654: boutput.setName(sqlFileName + "Response");
0655: bo.setBindingOutput(boutput);
0656: binding.addBindingOperation(bo);
0657: }
0658: }
0659: return binding;
0660: }
0661:
0662: private Message getMessageByName(String messageName) {
0663: QName qname = new QName("http://com.sun.jbi/sqlse/sqlseengine",
0664: messageName);
0665: return def.getMessage(qname);
0666: }
0667:
0668: private void modifyMessageElementName(Message message,
0669: String partName, String newElementName) {
0670: Part part = message.getPart(partName);
0671: if (part != null) {
0672: QName qname = new QName(
0673: "http://com.sun.jbi/sqlse/sqlseengine",
0674: newElementName);
0675: part.setElementName(qname);
0676: }
0677: }
0678:
0679: private void modifyServices(Binding binding) {
0680: Port p = null;
0681: QName qname = new QName(def.getTargetNamespace(), wsdlFileName
0682: + "_sqlseService");
0683: Service service = def.getService(qname);
0684: if (service == null) {
0685: service = def.createService();
0686: service.setQName(qname);
0687: p = def.createPort();
0688: p.setBinding(binding);
0689: p.setName(wsdlFileName + "_sqlsePort");
0690: service.addPort(p);
0691: def.addService(service);
0692: }
0693: }
0694:
0695: private void modifyPartnerLink() {
0696: if (!wsdlFileExsits) {
0697: List l = def.getExtensibilityElements();
0698: UnknownExtensibilityElement plinkType = (UnknownExtensibilityElement) l
0699: .get(0);
0700: //set plinkType name
0701: plinkType.getElement();
0702: String plinkName = plinkType.getElement().getAttribute(
0703: "name");
0704: plinkType.getElement().setAttribute("name",
0705: wsdlFileName + "_" + plinkName);
0706:
0707: //set plink:role name and portType
0708: NodeList nl = plinkType.getElement().getChildNodes();
0709: Element plinkRole = (Element) nl.item(1);
0710: plinkRole.setAttribute("name", wsdlFileName + "_"
0711: + plinkRole.getAttribute("name"));
0712:
0713: String temp = plinkRole.getAttribute("portType").substring(
0714: "tns:".length());
0715: plinkRole.setAttribute("portType", "tns:" + wsdlFileName
0716: + "_" + temp);
0717: }
0718:
0719: }
0720:
0721: private void generateDeleteSchemaElements(Element requestElement,
0722: Element responseElement) {
0723: try {
0724: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0725: if (requestElement != null) {
0726: Element sequenceElement = getElementByName(
0727: requestElement, "xsd:sequence");
0728: if (sequenceElement != null) {
0729: if (prep.getNumParameters() > 0) {
0730: addPreparedStmtParametersToElement(prep,
0731: sequenceElement);
0732: } else {
0733: //remove elements under the current requestItem.
0734: NodeList list = sequenceElement.getChildNodes();
0735: if (list != null) {
0736: for (int j = list.getLength() - 1; j >= 0; j--) {
0737: sequenceElement.removeChild(list
0738: .item(j));
0739: }
0740: }
0741:
0742: }
0743: //sequenceElement.removeChild(colElem1);
0744: }
0745: }
0746: if (responseElement != null) {
0747: Element colElem2 = getElementByName(responseElement,
0748: "xsd:sequence");
0749: if (colElem2 != null) {
0750: addResultSetColumnsToElement(prep, colElem2);
0751: //colElem2.getParentNode().removeChild(colElem2);
0752: }
0753: }
0754: } catch (Exception e) {
0755: logger.log(Level.SEVERE, e.getLocalizedMessage());
0756: }
0757: }
0758:
0759: private void generateCreateSchemaElements(Element requestElement,
0760: Element responseElement) {
0761: try {
0762: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0763: if (requestElement != null) {
0764: Element sequenceElement = getElementByName(
0765: requestElement, "xsd:sequence");
0766: if (sequenceElement != null) {
0767: if (prep.getNumParameters() > 0) {
0768: addPreparedStmtParametersToElement(prep,
0769: sequenceElement);
0770: } else {
0771: //remove elements under the current requestItem.
0772: NodeList list = sequenceElement.getChildNodes();
0773: if (list != null) {
0774: for (int j = list.getLength() - 1; j >= 0; j--) {
0775: sequenceElement.removeChild(list
0776: .item(j));
0777: }
0778: }
0779:
0780: }
0781: //sequenceElement.removeChild(colElem1);
0782: }
0783: }
0784: if (responseElement != null) {
0785: Element colElem2 = getElementByName(responseElement,
0786: "xsd:sequence");
0787: if (colElem2 != null) {
0788: addResultSetColumnsToElement(prep, colElem2);
0789: //colElem2.getParentNode().removeChild(colElem2);
0790: }
0791: }
0792: } catch (Exception e) {
0793: logger.log(Level.SEVERE, e.getLocalizedMessage());
0794: }
0795: }
0796:
0797: private void generateAlterSchemaElements(Element requestElement,
0798: Element responseElement) {
0799: try {
0800: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0801: if (requestElement != null) {
0802: Element sequenceElement = getElementByName(
0803: requestElement, "xsd:sequence");
0804: if (sequenceElement != null) {
0805: if (prep.getNumParameters() > 0) {
0806: addPreparedStmtParametersToElement(prep,
0807: sequenceElement);
0808: } else {
0809: //remove elements under the current requestItem.
0810: NodeList list = sequenceElement.getChildNodes();
0811: if (list != null) {
0812: for (int j = list.getLength() - 1; j >= 0; j--) {
0813: sequenceElement.removeChild(list
0814: .item(j));
0815: }
0816: }
0817:
0818: }
0819: //sequenceElement.removeChild(colElem1);
0820: }
0821: }
0822: if (responseElement != null) {
0823: Element colElem2 = getElementByName(responseElement,
0824: "xsd:sequence");
0825: if (colElem2 != null) {
0826: addResultSetColumnsToElement(prep, colElem2);
0827: //colElem2.getParentNode().removeChild(colElem2);
0828: }
0829: }
0830: } catch (Exception e) {
0831: logger.log(Level.SEVERE, e.getLocalizedMessage());
0832: }
0833: }
0834:
0835: private void generateDropSchemaElements(Element requestElement,
0836: Element responseElement) {
0837: try {
0838: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0839: if (requestElement != null) {
0840: Element sequenceElement = getElementByName(
0841: requestElement, "xsd:sequence");
0842: if (sequenceElement != null) {
0843: if (prep.getNumParameters() > 0) {
0844: addPreparedStmtParametersToElement(prep,
0845: sequenceElement);
0846: } else {
0847: //remove elements under the current requestItem.
0848: NodeList list = sequenceElement.getChildNodes();
0849: if (list != null) {
0850: for (int j = list.getLength() - 1; j >= 0; j--) {
0851: sequenceElement.removeChild(list
0852: .item(j));
0853: }
0854: }
0855:
0856: }
0857: //sequenceElement.removeChild(colElem1);
0858: }
0859: }
0860: if (responseElement != null) {
0861: Element colElem2 = getElementByName(responseElement,
0862: "xsd:sequence");
0863: if (colElem2 != null) {
0864: addResultSetColumnsToElement(prep, colElem2);
0865: //colElem2.getParentNode().removeChild(colElem2);
0866: }
0867: }
0868: } catch (Exception e) {
0869: logger.log(Level.SEVERE, e.getLocalizedMessage());
0870: }
0871: }
0872:
0873: private void generateTruncateSchemaElements(Element requestElement,
0874: Element responseElement) {
0875: try {
0876: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0877: if (requestElement != null) {
0878: Element sequenceElement = getElementByName(
0879: requestElement, "xsd:sequence");
0880: if (sequenceElement != null) {
0881: if (prep.getNumParameters() > 0) {
0882: addPreparedStmtParametersToElement(prep,
0883: sequenceElement);
0884: } else {
0885: //remove elements under the current requestItem.
0886: NodeList list = sequenceElement.getChildNodes();
0887: if (list != null) {
0888: for (int j = list.getLength() - 1; j >= 0; j--) {
0889: sequenceElement.removeChild(list
0890: .item(j));
0891: }
0892: }
0893:
0894: }
0895: //sequenceElement.removeChild(colElem1);
0896: }
0897: }
0898: if (responseElement != null) {
0899: Element colElem2 = getElementByName(responseElement,
0900: "xsd:sequence");
0901: if (colElem2 != null) {
0902: addResultSetColumnsToElement(prep, colElem2);
0903: //colElem2.getParentNode().removeChild(colElem2);
0904: }
0905: }
0906: } catch (Exception e) {
0907: logger.log(Level.SEVERE, e.getLocalizedMessage());
0908: }
0909: }
0910:
0911: private void generateInsertSchemaElements(Element requestElement,
0912: Element responseElement) throws Exception {
0913: try {
0914: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0915: if (requestElement != null) {
0916: Element sequenceElement = getElementByName(
0917: requestElement, "xsd:sequence");
0918: if (sequenceElement != null) {
0919: if (prep.getNumParameters() > 0) {
0920: addPreparedStmtParametersToElement(prep,
0921: sequenceElement);
0922: } else {
0923: //remove elements under the current requestItem.
0924: NodeList list = sequenceElement.getChildNodes();
0925: if (list != null) {
0926: for (int j = list.getLength() - 1; j >= 0; j--) {
0927: sequenceElement.removeChild(list
0928: .item(j));
0929: }
0930: }
0931:
0932: }
0933: //sequenceElement.removeChild(colElem1);
0934: }
0935: }
0936: if (responseElement != null) {
0937: Element colElem2 = getElementByName(responseElement,
0938: "xsd:sequence");
0939: if (colElem2 != null) {
0940: addResultSetColumnsToElement(prep, colElem2);
0941: //colElem2.getParentNode().removeChild(colElem2);
0942: }
0943: }
0944: } catch (Exception e) {
0945: logger.log(Level.SEVERE, e.getLocalizedMessage());
0946: throw e;
0947: }
0948: }
0949:
0950: /**
0951: * Adds a whereClause to the request element and resultset to the result element.
0952: * @param requestElement
0953: * @param responseElement
0954: */
0955: private void generateSelectSchemaElements(Element requestElement,
0956: Element responseElement) {
0957: try {
0958: PrepStmt prep = dbmeta.getPrepStmtMetaData();
0959: if (requestElement != null) {
0960: Element sequenceElement = getElementByName(
0961: requestElement, "xsd:sequence");
0962: if (sequenceElement != null) {
0963: if (prep.getNumParameters() > 0) {
0964: addPreparedStmtParametersToElement(prep,
0965: sequenceElement);
0966: } else {
0967: //remove elements under the current requestItem.
0968: NodeList list = sequenceElement.getChildNodes();
0969: if (list != null) {
0970: for (int j = list.getLength() - 1; j >= 0; j--) {
0971: sequenceElement.removeChild(list
0972: .item(j));
0973: }
0974: }
0975:
0976: }
0977: //sequenceElement.removeChild(colElem1);
0978: }
0979: }
0980: if (responseElement != null) {
0981: Element colElem2 = getElementByName(responseElement,
0982: "xsd:sequence");
0983: if (colElem2 != null) {
0984: addResultSetColumnsToElement(prep, colElem2);
0985: //colElem2.getParentNode().removeChild(colElem2);
0986: }
0987: }
0988: } catch (Exception e) {
0989: logger.log(Level.SEVERE, e.getLocalizedMessage());
0990: }
0991: }
0992:
0993: /**
0994: * Adds Input parameters to the request element and resultset to the result element.
0995: * @param requestElement
0996: * @param responseElement
0997: */
0998: private void generateProcSchemaElements(Element requestElement,
0999: Element responseElement) {
1000: try {
1001: String catalog = conn.getCatalog();
1002: schema = dbConn.getSchema();
1003: String procName = getProcName();
1004: if (catalog == null) {
1005: catalog = "";
1006: }
1007: Procedure proc = dbmeta.getProcedureMetaData(catalog,
1008: schema, procName, "Procedure");
1009: if (proc.getHasReturn()) {
1010: //dbmeta.getProcResultSetColumns(catalog, schema, procName, "Procedure", proc);
1011: }
1012: if (requestElement != null) {
1013: Element sequenceElement = getElementByName(
1014: requestElement, "xsd:sequence");
1015: if (sequenceElement != null) {
1016: if (proc.getNumParameters() > 0) {
1017: addProcedureParametersToElement(proc,
1018: sequenceElement);
1019: } else {
1020: //remove elements under the current requestItem.
1021: NodeList list = sequenceElement.getChildNodes();
1022: if (list != null) {
1023: for (int j = list.getLength() - 1; j >= 0; j--) {
1024: sequenceElement.removeChild(list
1025: .item(j));
1026: }
1027: }
1028:
1029: }
1030: //sequenceElement.removeChild(colElem1);
1031: }
1032: }
1033: if (responseElement != null) {
1034: Element colElem2 = getElementByName(responseElement,
1035: "xsd:sequence");
1036: if (colElem2 != null) {
1037: addProcedureResultSetColumnsToElement(proc,
1038: colElem2);
1039: //colElem2.getParentNode().removeChild(colElem2);
1040: }
1041: }
1042: } catch (Exception e) {
1043: logger.log(Level.SEVERE, e.getLocalizedMessage());
1044: }
1045: }
1046:
1047: /**
1048: * Given a xml Element and a Prepstmnt object, adds the resultset columns
1049: * and their types as sub elements.
1050: * @param prep
1051: * @param sequenceElement
1052: */
1053: private void addResultSetColumnsToElement(PrepStmt prep,
1054: Element sequenceElement) throws WSDLException {
1055: String colType = null;
1056: if (sequenceElement != null) {
1057: NodeList list = sequenceElement.getChildNodes();
1058: if (list != null) {
1059: for (int j = list.getLength() - 1; j >= 0; j--) {
1060: sequenceElement.removeChild(list.item(j));
1061: }
1062: }
1063: }
1064: if (prep != null) {
1065: ResultSetColumn[] rs = prep.getResultSetColumns();
1066: if (rs != null && rs.length > 0) {
1067: for (int i = 0; i < rs.length; i++) {
1068: try {
1069: colType = rs[i].getJavaType();
1070: Element elem = null;
1071: if (isBuiltInType(colType)) {
1072: elem = createElement(rs[i].getName(),
1073: (String) WSDLGenerator.builtInTypes
1074: .get(colType));
1075: } else {
1076: throw new WSDLException(
1077: WSDLException.INVALID_WSDL,
1078: "Invalid datatype encountered");
1079: }
1080: sequenceElement.appendChild(elem);
1081: } catch (WSDLException e) {
1082: logger.log(Level.SEVERE, e
1083: .getLocalizedMessage());
1084: throw new WSDLException(
1085: WSDLException.INVALID_WSDL,
1086: "Check if the sql entered is valid");
1087: }
1088: }
1089: }
1090: }
1091: }
1092:
1093: /**
1094: * Given a xml Element and a Procedure object, adds the resultset columns
1095: * and their types as sub elements.
1096: * @param proc
1097: * @param sequenceElement
1098: */
1099: private void addProcedureResultSetColumnsToElement(Procedure proc,
1100: Element sequenceElement) throws WSDLException {
1101: String colType = null;
1102: if (sequenceElement != null) {
1103: NodeList list = sequenceElement.getChildNodes();
1104: if (list != null) {
1105: for (int j = list.getLength() - 1; j >= 0; j--) {
1106: sequenceElement.removeChild(list.item(j));
1107: }
1108: }
1109: }
1110: if (proc != null) {
1111: ResultSetColumns[] rss = proc.getResultSetColumnsArray();
1112: for (int j = 0; j < rss.length; j++) {
1113: ResultSetColumn rs = rss[j].get(j);
1114: if (rs != null) {
1115: try {
1116: colType = rs.getJavaType();
1117: Element elem = null;
1118: if (isBuiltInType(colType)) {
1119: elem = createElement(rs.getName(),
1120: (String) WSDLGenerator.builtInTypes
1121: .get(colType));
1122: } else {
1123: throw new WSDLException(
1124: WSDLException.INVALID_WSDL,
1125: "Invalid datatype encountered");
1126: }
1127: sequenceElement.appendChild(elem);
1128: } catch (WSDLException e) {
1129: logger.log(Level.SEVERE, e
1130: .getLocalizedMessage());
1131: throw new WSDLException(
1132: WSDLException.INVALID_WSDL,
1133: "Check if the sql entered is valid");
1134: }
1135: }
1136: }
1137:
1138: }
1139: }
1140:
1141: /**
1142: * Adds prepared statement parameters to the element.
1143: * @param prep
1144: * @param sequenceElement
1145: */
1146: private void addPreparedStmtParametersToElement(PrepStmt prep,
1147: Element sequenceElement) {
1148: if (prep.getNumParameters() > 0) {
1149: if (sequenceElement != null) {
1150: NodeList list = sequenceElement.getChildNodes();
1151: if (list != null) {
1152: for (int j = list.getLength() - 1; j >= 0; j--) {
1153: sequenceElement.removeChild(list.item(j));
1154: }
1155: }
1156: Parameter[] params = prep.getParameters();
1157: for (int i = 0; i < prep.getNumParameters(); i++) {
1158: Element elem2 = createElement(params[i].getName(),
1159: (String) WSDLGenerator.builtInTypes
1160: .get(params[i].getJavaType()));
1161: sequenceElement.appendChild(elem2);
1162: }
1163:
1164: }
1165: }
1166: }
1167:
1168: /**
1169: * Adds Procedure parameters to the element.
1170: * @param prep
1171: * @param sequenceElement
1172: */
1173: private void addProcedureParametersToElement(Procedure prep,
1174: Element sequenceElement) {
1175: if (prep.getNumParameters() > 0) {
1176: if (sequenceElement != null) {
1177: NodeList list = sequenceElement.getChildNodes();
1178: if (list != null) {
1179: for (int j = list.getLength() - 1; j >= 0; j--) {
1180: sequenceElement.removeChild(list.item(j));
1181: }
1182: }
1183: Parameter[] params = prep.getParameters();
1184: for (int i = 0; i < prep.getNumParameters(); i++) {
1185: Element elem2 = createElement(params[i].getName(),
1186: (String) WSDLGenerator.builtInTypes
1187: .get(params[i].getJavaType()));
1188: sequenceElement.appendChild(elem2);
1189: }
1190:
1191: }
1192: }
1193: }
1194:
1195: /**
1196: * Helper method to return the Element with the name elementName from a
1197: * top level element e. The method recursively looks thru sub elements and
1198: * returns it once it is found. or a null.
1199: * @param e
1200: * @param elementName
1201: * @return
1202: */
1203: private Element getElementByName(Element e, String elementName) {
1204: if (e.getAttribute("name").equalsIgnoreCase(elementName)) {
1205: return e;
1206: }
1207: NodeList list = e.getChildNodes();
1208: Element el = null;
1209: Element e2 = null;
1210: for (int i = 0; i < list.getLength(); i++) {
1211: if (e2 == null) {
1212: Node n = list.item(i);
1213: if (n.getNodeType() == Node.ELEMENT_NODE) {
1214: el = (Element) n;
1215: if ((el.getAttribute("name")
1216: .equalsIgnoreCase(elementName))
1217: || el.getTagName().equalsIgnoreCase(
1218: elementName)
1219: || ((el.getLocalName() != null) && el
1220: .getLocalName().equalsIgnoreCase(
1221: elementName))) {
1222: e2 = el;
1223: break;
1224: } else {
1225: e2 = getElementByName(el, elementName);
1226: if ((e2 != null)
1227: && (e2.getAttribute("name")
1228: .equalsIgnoreCase(elementName))) {
1229: return e2;
1230: }
1231: }
1232: }
1233: } else {
1234: break;
1235: }
1236: }
1237: return e2;
1238: }
1239:
1240: /**
1241: * Helper method which sets the sql statement type from the sql text.
1242: * @param sqlText
1243: */
1244: private void parseSQLStatement(String sqlText) {
1245: sqlText = sqlText.trim();
1246: String modSQLText = sqlText.toUpperCase();
1247: if (modSQLText.startsWith(SELECT_STATEMENT)) {
1248: STATEMENT_TYPE = SELECT_STATEMENT;
1249: } else if (modSQLText.startsWith(INSERT_STATEMENT)) {
1250: STATEMENT_TYPE = INSERT_STATEMENT;
1251: } else if (modSQLText.startsWith(UPDATE_STATEMENT)) {
1252: STATEMENT_TYPE = UPDATE_STATEMENT;
1253: } else if (modSQLText.startsWith(DELETE_STATEMENT)) {
1254: STATEMENT_TYPE = DELETE_STATEMENT;
1255: } else if (modSQLText.startsWith(TRUNCATE_STATEMENT)) {
1256: STATEMENT_TYPE = TRUNCATE_STATEMENT;
1257: } else if (modSQLText.startsWith(DDL_STATEMENT_CREATE)) {
1258: STATEMENT_TYPE = DDL_STATEMENT_CREATE;
1259: } else if (modSQLText.startsWith(DDL_STATEMENT_ALTER)) {
1260: STATEMENT_TYPE = DDL_STATEMENT_ALTER;
1261: } else if (modSQLText.startsWith(DDL_STATEMENT_DROP)) {
1262: STATEMENT_TYPE = DDL_STATEMENT_DROP;
1263: } else {
1264: STATEMENT_TYPE = PROC_STATEMENT;
1265: }
1266:
1267: }
1268:
1269: /**
1270: * persist the wsdl file to disk
1271: *
1272: * @throws WSDLException
1273: */
1274: private void writeWsdl() throws WSDLException {
1275: try {
1276: WSDLWriter writer = factory.newWSDLWriter();
1277: Writer sink = new FileWriter(wsdlFileLocation
1278: + File.separator + wsdlFileName + ".wsdl");
1279: writer.writeWSDL(def, sink);
1280: logger.log(Level.INFO, "Successfully generated wsdl file:"
1281: + wsdlFileName + ".wsdl");
1282: } catch (Exception e) {
1283: throw new WSDLException(WSDLException.OTHER_ERROR, e
1284: .getMessage());
1285: }
1286:
1287: }
1288:
1289: private void indentWSDLFile(Writer writer) {
1290: try {
1291: // Use a Transformer for output
1292: TransformerFactory tFactory = TransformerFactory
1293: .newInstance();
1294: Transformer transformer = tFactory.newTransformer();
1295: DOMSource source = new DOMSource(doc);
1296: PrintWriter pw = new PrintWriter(writer); //USE PRINTWRITER
1297: StreamResult result = new StreamResult(pw);
1298: transformer.setOutputProperty(OutputKeys.METHOD, "xml"); // NOI18N
1299: transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); // NOI18N
1300: transformer.setOutputProperty(OutputKeys.MEDIA_TYPE,
1301: "text/xml"); // NOI18N
1302: //transformer.setOutputProperty(OutputKeys.STANDALONE, "yes"); // NOI18N
1303: // indent the output to make it more legible...
1304: try {
1305: transformer.setOutputProperty(
1306: "{http://xml.apache.org/xslt}indent-amount",
1307: "4"); // NOI18N
1308: transformer.setOutputProperty(OutputKeys.INDENT, "yes"); // NOI18N
1309: } catch (Exception e) {
1310: ; // the JAXP implementation doesn't support indentation, no big deal
1311: }
1312: transformer.transform(source, result);
1313: } catch (Exception e) {
1314: logger.log(Level.WARNING, "Unable to indent wsdl file "
1315: + e.getLocalizedMessage());
1316: }
1317:
1318: }
1319:
1320: /**
1321: * Check if the column type is a xsd built in type.
1322: * @param type
1323: * @return
1324: */
1325: public static boolean isBuiltInType(String type) {
1326: return (builtInTypes.get(type) != null);
1327: }
1328:
1329: private Element createElementWithComplexType(String name) {
1330: Element elem = doc.createElement("xsd:element");
1331: elem.setAttribute("name", name);
1332: Element complexType = doc.createElement("xsd:complexType");
1333: Element sequence = doc.createElement("xsd:sequence");
1334: complexType.appendChild(sequence);
1335: elem.appendChild(complexType);
1336: return elem;
1337: }
1338:
1339: private Element createElement(String name, String type) {
1340: Element elem = doc.createElementNS(
1341: "http://www.w3.org/2001/XMLSchema", "xsd:element");
1342: elem.setAttribute("name", name);
1343: elem.setAttribute("type", type);
1344: return elem;
1345: }
1346:
1347: private void removeSchemaElements(Element requestElement,
1348: Element responseElement) {
1349: try {
1350: if (requestElement != null) {
1351: Element sequenceElement = getElementByName(
1352: requestElement, "xsd:sequence");
1353: if (sequenceElement != null) {
1354:
1355: //remove elements under the current requestItem.
1356: NodeList list = sequenceElement.getChildNodes();
1357: if (list != null) {
1358: for (int j = list.getLength() - 1; j >= 0; j--) {
1359: sequenceElement.removeChild(list.item(j));
1360: }
1361: }
1362: //sequenceElement.removeChild(colElem1);
1363: }
1364: }
1365: if (responseElement != null) {
1366: if (responseElement != null) {
1367: NodeList list = responseElement.getChildNodes();
1368: if (list != null) {
1369: for (int j = list.getLength() - 1; j >= 0; j--) {
1370: responseElement.removeChild(list.item(j));
1371: }
1372: }
1373: }
1374: }
1375: } catch (Exception e) {
1376: logger.log(Level.SEVERE, e.getLocalizedMessage());
1377: }
1378: }
1379:
1380: public void setDBConnection(DatabaseConnection con) {
1381: this .dbConn = con;
1382: this .schema = schema;
1383: }
1384:
1385: private String getProcName() {
1386: String proc_name = "";
1387: String schema = "";
1388: final StringTokenizer tok = new StringTokenizer(dbmeta
1389: .getSQLText(), " ");
1390:
1391: while (tok.hasMoreElements()) {
1392: String column = (String) tok.nextElement();
1393: int cnt = 0;
1394: column = column.toLowerCase();
1395: if (column.endsWith("call")) {
1396: cnt++;
1397: proc_name = (String) tok.nextElement();
1398: if (proc_name.contains(".")) {
1399: final StringTokenizer tok1 = new StringTokenizer(
1400: proc_name, ".");
1401: schema = tok1.nextToken();
1402: proc_name = tok1.nextToken();
1403: }
1404: if (proc_name.contains("(")) {
1405: int i = proc_name.indexOf("(");
1406: proc_name = proc_name.substring(0, i);
1407: }
1408: if (proc_name.contains("}")) {
1409: int i = proc_name.indexOf("}");
1410: proc_name = proc_name.substring(0, i);
1411: }
1412: }
1413: if (cnt > 0)
1414: break;
1415: }
1416: return proc_name;
1417: }
1418: }
|