/*
* ModeShape (http://www.modeshape.org)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.modeshape.sequencer.ddl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.modeshape.common.annotation.Immutable;
import org.modeshape.common.text.ParsingException;
import org.modeshape.common.text.Position;
import org.modeshape.common.util.CheckArg;
import org.modeshape.jcr.api.JcrConstants;
import org.modeshape.sequencer.ddl.dialect.derby.DerbyDdlParser;
import org.modeshape.sequencer.ddl.dialect.oracle.OracleDdlParser;
import org.modeshape.sequencer.ddl.dialect.postgres.PostgresDdlParser;
import org.modeshape.sequencer.ddl.dialect.teiid.TeiidDdlParser;
import org.modeshape.sequencer.ddl.node.AstNode;
import org.modeshape.sequencer.ddl.node.AstNodeFactory;
/**
* A set of parsers capable of understanding DDL file content. This class can be used directly to create an {@link AstNode} tree
* representing nodes and properties for DDL statement components.
* <p>
* You can also provide an input or parent {@link AstNode} node as the starting point for your tree.
* </p>
* <p>
* The parser is based on the SQL-92 and extended by specific dialects. These dialect-specific parsers provide db-specific parsing
* of db-specific statements of statement extensions, features or properties.
* </p>
*/
@Immutable
public class DdlParsers {
/**
* Sorts the parser scores.
*/
private static final Comparator<Entry<DdlParser, Integer>> SORTER = new Comparator<Entry<DdlParser, Integer>>() {
@Override
public int compare( final Entry<DdlParser, Integer> thisEntry,
final Entry<DdlParser, Integer> thatEntry ) {
// reverse order as we want biggest value to sort first
int result = (thisEntry.getValue().compareTo(thatEntry.getValue()) * -1);
// default to standard SQL parser if score is a tie
if (result == 0) {
if (StandardDdlParser.ID.equals(thisEntry.getKey().getId())
&& !StandardDdlParser.ID.equals(thatEntry.getKey().getId())) {
return -1;
}
if (StandardDdlParser.ID.equals(thatEntry.getKey().getId())
&& !StandardDdlParser.ID.equals(thisEntry.getKey().getId())) {
return 1;
}
}
return result;
}
};
public static final List<DdlParser> BUILTIN_PARSERS;
static {
List<DdlParser> parsers = new ArrayList<DdlParser>();
parsers.add(new StandardDdlParser());
parsers.add(new OracleDdlParser());
parsers.add(new DerbyDdlParser());
parsers.add(new PostgresDdlParser());
parsers.add(new TeiidDdlParser());
BUILTIN_PARSERS = Collections.unmodifiableList(parsers);
}
private List<DdlParser> parsers;
private AstNodeFactory nodeFactory = new AstNodeFactory();
/**
* Create an instance that uses all of the {@link #BUILTIN_PARSERS built-in parsers}.
*/
public DdlParsers() {
this.parsers = BUILTIN_PARSERS;
}
/**
* Create an instance that uses the supplied parsers, in order.
*
* @param parsers the list of parsers; may be empty or null if the {@link #BUILTIN_PARSERS built-in parsers} should be used
*/
public DdlParsers( List<DdlParser> parsers ) {
this.parsers = (parsers != null && !parsers.isEmpty()) ? parsers : BUILTIN_PARSERS;
}
private AstNode createDdlStatementsContainer( final String parserId ) {
final AstNode node = this.nodeFactory.node(StandardDdlLexicon.STATEMENTS_CONTAINER);
node.setProperty(JcrConstants.JCR_PRIMARY_TYPE, JcrConstants.NT_UNSTRUCTURED);
node.setProperty(StandardDdlLexicon.PARSER_ID, parserId);
return node;
}
/**
* @param id the identifier of the parser being requested (cannot be <code>null</code> or empty)
* @return the parser or <code>null</code> if not found
*/
public DdlParser getParser( final String id ) {
CheckArg.isNotEmpty(id, "id");
for (final DdlParser parser : this.parsers) {
if (parser.getId().equals(id)) {
return parser;
}
}
return null;
}
/**
* @return a copy of the DDL parsers used in this instance (never <code>null</code> or empty)
*/
public Set<DdlParser> getParsers() {
return new HashSet<DdlParser>(this.parsers);
}
/**
* @param ddl the DDL being parsed (cannot be <code>null</code> or empty)
* @param parserId the identifier of the parser to use (can be <code>null</code> or empty if best matched parser should be
* used)
* @return the root tree {@link AstNode}
* @throws ParsingException if there is an error parsing the supplied DDL content
* @throws IllegalArgumentException if a parser with the specified identifier cannot be found
*/
public AstNode parseUsing( final String ddl,
final String parserId ) throws ParsingException {
CheckArg.isNotEmpty(ddl, "ddl");
CheckArg.isNotEmpty(parserId, "parserId");
DdlParser parser = getParser(parserId);
if (parser == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION, DdlSequencerI18n.unknownParser.text(parserId));
}
// create DDL root node
AstNode astRoot = createDdlStatementsContainer(parserId);
// parse
parser.parse(ddl, astRoot, null);
return astRoot;
}
/**
* Parse the supplied DDL using multiple parsers, returning the result of each parser with its score in the order of highest
* scoring to lowest scoring.
*
* @param ddl the DDL being parsed (cannot be <code>null</code> or empty)
* @param firstParserId the identifier of the first parser to use (cannot be <code>null</code> or empty)
* @param secondParserId the identifier of the second parser to use (cannot be <code>null</code> or empty)
* @param additionalParserIds the identifiers of additional parsers that should be used; may be empty but not contain a null
* identifier value
* @return the list of {@link ParsingResult} instances, one for each parser, ordered from highest score to lowest score (never
* <code>null</code> or empty)
* @throws ParsingException if there is an error parsing the supplied DDL content
* @throws IllegalArgumentException if a parser with the specified identifier cannot be found
*/
public List<ParsingResult> parseUsing( final String ddl,
final String firstParserId,
final String secondParserId,
final String... additionalParserIds ) throws ParsingException {
CheckArg.isNotEmpty(firstParserId, "firstParserId");
CheckArg.isNotEmpty(secondParserId, "secondParserId");
if (additionalParserIds != null) {
CheckArg.containsNoNulls(additionalParserIds, "additionalParserIds");
}
final int numParsers = ((additionalParserIds == null) ? 2 : (additionalParserIds.length + 2));
final List<DdlParser> selectedParsers = new ArrayList<DdlParser>(numParsers);
{ // add first parser
final DdlParser parser = getParser(firstParserId);
if (parser == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION, DdlSequencerI18n.unknownParser.text(firstParserId));
}
selectedParsers.add(parser);
}
{ // add second parser
final DdlParser parser = getParser(secondParserId);
if (parser == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION, DdlSequencerI18n.unknownParser.text(secondParserId));
}
selectedParsers.add(parser);
}
// add remaining parsers
if ((additionalParserIds != null) && (additionalParserIds.length != 0)) {
for (final String id : additionalParserIds) {
final DdlParser parser = getParser(id);
if (parser == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION, DdlSequencerI18n.unknownParser.text(id));
}
selectedParsers.add(parser);
}
}
return parseUsing(ddl, selectedParsers);
}
private List<ParsingResult> parseUsing( final String ddl,
final List<DdlParser> parsers ) {
CheckArg.isNotEmpty(ddl, "ddl");
final List<ParsingResult> results = new ArrayList<DdlParsers.ParsingResult>(this.parsers.size());
final DdlParserScorer scorer = new DdlParserScorer();
for (final DdlParser parser : this.parsers) {
final String parserId = parser.getId();
int score = ParsingResult.NO_SCORE;
AstNode rootNode = null;
Exception error = null;
try {
// score
final Object scorerOutput = parser.score(ddl, null, scorer);
score = scorer.getScore();
// create DDL root node
rootNode = createDdlStatementsContainer(parserId);
// parse
parser.parse(ddl, rootNode, scorerOutput);
} catch (final RuntimeException e) {
error = e;
} finally {
final ParsingResult result = new ParsingResult(parserId, rootNode, score, error);
results.add(result);
scorer.reset();
}
}
Collections.sort(results);
return results;
}
/**
* Parse the supplied DDL using all registered parsers, returning the result of each parser with its score in the order of
* highest scoring to lowest scoring.
*
* @param ddl the DDL being parsed (cannot be <code>null</code> or empty)
* @return the list or {@link ParsingResult} instances, one for each parser, ordered from highest score to lowest score
* @throws ParsingException if there is an error parsing the supplied DDL content
* @throws IllegalArgumentException if a parser with the specified identifier cannot be found
*/
public List<ParsingResult> parseUsingAll( final String ddl ) throws ParsingException {
return parseUsing(ddl, this.parsers);
}
/**
* Parse the supplied DDL content and return the {@link AstNode root node} of the AST representation.
*
* @param ddl content string; may not be null
* @param fileName the approximate name of the file containing the DDL content; may be null if this is not known
* @return the root tree {@link AstNode}
* @throws ParsingException if there is an error parsing the supplied DDL content
*/
public AstNode parse( final String ddl,
final String fileName ) throws ParsingException {
CheckArg.isNotEmpty(ddl, "ddl");
RuntimeException firstException = null;
// Go through each parser and score the DDL content
final Map<DdlParser, Integer> scoreMap = new HashMap<DdlParser, Integer>(this.parsers.size());
final DdlParserScorer scorer = new DdlParserScorer();
for (final DdlParser parser : this.parsers) {
try {
parser.score(ddl, fileName, scorer);
scoreMap.put(parser, scorer.getScore());
} catch (RuntimeException e) {
if (firstException == null) {
firstException = e;
}
} finally {
scorer.reset();
}
}
if (scoreMap.isEmpty()) {
if (firstException == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION,
DdlSequencerI18n.errorParsingDdlContent.text(this.parsers.size()));
}
throw firstException;
}
// sort the scores
final List<Entry<DdlParser, Integer>> scoredParsers = new ArrayList<Entry<DdlParser, Integer>>(scoreMap.entrySet());
Collections.sort(scoredParsers, SORTER);
firstException = null;
AstNode astRoot = null;
for (final Entry<DdlParser, Integer> scoredParser : scoredParsers) {
try {
final DdlParser parser = scoredParser.getKey();
// create DDL root node
astRoot = createDdlStatementsContainer(parser.getId());
// parse
parser.parse(ddl, astRoot, null);
return astRoot; // successfully parsed
} catch (final RuntimeException e) {
if (astRoot != null) {
astRoot.removeFromParent();
}
if (firstException == null) {
firstException = e;
}
}
}
if (firstException == null) {
throw new ParsingException(Position.EMPTY_CONTENT_POSITION, DdlSequencerI18n.errorParsingDdlContent.text());
}
throw firstException;
}
/**
* Represents a parsing result of one parser parsing one DDL input.
*/
@Immutable
public class ParsingResult implements Comparable<ParsingResult> {
public static final int NO_SCORE = -1;
private final Exception error;
private final String id;
private final AstNode rootNode;
private final int score;
/**
* @param parserId the parser identifier (cannot be <code>null</code> or empty)
* @param rootTreeNode the node at the root of the parse tree (can be <code>null</code> if an error occurred)
* @param parserScore the parsing score (can have {@link #NO_SCORE no score} if an error occurred
* @param parsingError an error that occurred during parsing (can be <code>null</code>)
*/
public ParsingResult( final String parserId,
final AstNode rootTreeNode,
final int parserScore,
final Exception parsingError ) {
CheckArg.isNotEmpty(parserId, "parserId");
this.id = parserId;
this.rootNode = rootTreeNode;
this.score = parserScore;
this.error = parsingError;
}
/**
* {@inheritDoc}
*
* @see java.lang.Comparable#compareTo(java.lang.Object)
*/
@Override
public int compareTo( final ParsingResult that ) {
if ((this == that) || (this.score == that.score)) {
return 0;
}
return ((this.score > that.score) ? -1 : 1);
}
/**
* @return the parsing error (<code>null</code> if no error occurred)
*/
public Exception getError() {
return this.error;
}
/**
* @return the parser identifier (never <code>null</code> or empty)
*/
public String getParserId() {
return this.id;
}
/**
* @return the root <code>AstNode</code> (can be <code>null</code> if a parsing error occurred)
*/
public AstNode getRootTree() {
return this.rootNode;
}
/**
* @return the parsing score
*/
public int getScore() {
return this.score;
}
}
}