Exemple #1
0
  /**
   * Parses a XML input file and returns a newly created and populated Database structure.
   *
   * @param xmlFile The input file to parse.
   * @return Database populated by <code>xmlFile</code>.
   */
  public KualiDatabase parseFile(String xmlFile) throws EngineException {
    try {
      // in case I am missing something, make it obvious
      if (!firstPass) {
        throw new Error("No more double pass");
      }
      // check to see if we alread have parsed the file
      if ((alreadyReadFiles != null) && alreadyReadFiles.contains(xmlFile)) {
        return database;
      } else if (alreadyReadFiles == null) {
        alreadyReadFiles = new Vector(3, 1);
      }

      // remember the file to avoid looping
      alreadyReadFiles.add(xmlFile);

      currentXmlFile = xmlFile;

      saxFactory.setValidating(false);
      SAXParser parser = saxFactory.newSAXParser();

      FileInputStream fileInputStream = null;
      try {
        fileInputStream = new FileInputStream(xmlFile);
      } catch (FileNotFoundException fnfe) {
        throw new FileNotFoundException(new File(xmlFile).getAbsolutePath());
      }
      BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
      try {
        log.info("Parsing file: '" + (new File(xmlFile)).getName() + "'");
        InputSource is = new InputSource(bufferedInputStream);
        is.setSystemId(xmlFile);
        parser.parse(is, this);
      } finally {
        bufferedInputStream.close();
      }
    } catch (SAXParseException e) {
      throw new EngineException(
          "Sax error on line "
              + e.getLineNumber()
              + " column "
              + e.getColumnNumber()
              + " : "
              + e.getMessage(),
          e);
    } catch (Exception e) {
      throw new EngineException(e);
    }
    if (!isExternalSchema) {
      firstPass = false;
    }
    database.doFinalInitialization();
    return database;
  }
Exemple #2
0
  public void setOption(Attributes attributes) {
    // Look thru supported model elements in reverse order to
    // find one that this option statement applies to.

    String key = attributes.getValue("key");
    String value = attributes.getValue("value");
    if (currUnique != null) {
      currUnique.addOption(key, value);
    } else if (currIndex != null) {
      currIndex.addOption(key, value);
    } else if (currFK != null) {
      currFK.addOption(key, value);
    } else if (currColumn != null) {
      currColumn.addOption(key, value);
    } else if (currTable != null) {
      currTable.addOption(key, value);
    } else { // Must be a db level option.
      database.addOption(key, value);
    }
  }
Exemple #3
0
  /**
   * Handles opening elements of the xml file.
   *
   * @param uri
   * @param localName The local name (without prefix), or the empty string if Namespace processing
   *     is not being performed.
   * @param rawName The qualified name (with prefix), or the empty string if qualified names are not
   *     available.
   * @param attributes The specified or defaulted attributes
   */
  public void startElement(String uri, String localName, String rawName, Attributes attributes)
      throws SAXException {
    try {
      if (rawName.equals("database")) {
        if (isExternalSchema) {
          currentPackage = attributes.getValue("package");
          if (currentPackage == null) {
            currentPackage = defaultPackage;
          }
        } else {
          database.loadFromXML(attributes);
          if (database.getPackage() == null) {
            database.setPackage(defaultPackage);
          }
        }
      } else if (rawName.equals("external-schema")) {
        String xmlFile = attributes.getValue("filename");
        if (xmlFile.charAt(0) != '/') {
          File f = new File(currentXmlFile);
          xmlFile = new File(f.getParent(), xmlFile).getPath();
        }

        // put current state onto the stack
        ParseStackElement.pushState(this);

        isExternalSchema = true;

        parseFile(xmlFile);
        // get the last state from the stack
        ParseStackElement.popState(this);
      } else if (rawName.equals("domain")) {
        Domain domain = new Domain();
        domain.loadFromXML(attributes, database.getPlatform());
        database.addDomain(domain);
      } else if (rawName.equals("table")) {
        currTable = database.addTable(attributes);
        if (isExternalSchema) {
          currTable.setForReferenceOnly(true);
          currTable.setPackage(currentPackage);
        }
      } else if (rawName.equals("view")) {
        currView = database.addView(attributes);
      } else if (rawName.equals("sequence")) {
        currSequence = database.addSequence(attributes);
      } else if (rawName.equals("column")) {
        currColumn = currTable.addColumn(attributes);
      } else if (rawName.equals("inheritance")) {
        currColumn.addInheritance(attributes);
      } else if (rawName.equals("foreign-key")) {
        currFK = currTable.addForeignKey(attributes);
      } else if (rawName.equals("reference")) {
        currFK.addReference(attributes);
      } else if (rawName.equals("index")) {
        currIndex = currTable.addIndex(attributes);
      } else if (rawName.equals("index-column")) {
        currIndex.addColumn(attributes);
      } else if (rawName.equals("unique")) {
        currUnique = currTable.addUnique(attributes);
      } else if (rawName.equals("unique-column")) {
        currUnique.addColumn(attributes);
      } else if (rawName.equals("id-method-parameter")) {
        currTable.addIdMethodParameter(attributes);
      } else if (rawName.equals("option")) {
        setOption(attributes);
      }
    } catch (Exception e) {
      throw new SAXException(e);
    }
  }