Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/DdlConstants.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/DdlConstants.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/DdlConstants.java (working copy) @@ -5,6 +5,11 @@ import java.util.List; import org.modeshape.graph.property.Name; public interface DdlConstants { + + public static final long KILO = 1024; + public static final long MEGA = KILO * 1024; + public static final long GIGA = MEGA * 1024; + public static final String DEFAULT_TERMINATOR = ";"; /* Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataType.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataType.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataType.java (working copy) @@ -30,11 +30,9 @@ import org.modeshape.sequencer.ddl.DdlConstants; */ public class DataType { private String name; - private int length = -1; + private long length = -1; private int precision = -1; private int scale = -1; - private boolean isKMGLength = false; - private String kmgValue = null; /** * The statement source. @@ -74,11 +72,11 @@ public class DataType { this.name = value; } - public void setLength( int value ) { + public void setLength( long value ) { this.length = value; } - public int getLength() { + public long getLength() { return this.length; } @@ -106,22 +104,6 @@ public class DataType { return result.toString(); } - public boolean isKMGLength() { - return isKMGLength; - } - - public void setKMGLength( boolean isKMGLength ) { - this.isKMGLength = isKMGLength; - } - - public String getKMGValue() { - return kmgValue; - } - - public void setKMGValue( String kmgValue ) { - this.kmgValue = kmgValue; - } - /** * @param source */ Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataTypeParser.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataTypeParser.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/datatype/DataTypeParser.java (working copy) @@ -313,27 +313,27 @@ public class DataTypeParser implements DdlConstants { typeName = getStatementTypeName(DataTypes.DTYPE_VARCHAR); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_VARCHAR); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_CHAR_VARYING)) { typeName = getStatementTypeName(DataTypes.DTYPE_CHAR_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_CHAR_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_CHARACTER_VARYING)) { typeName = getStatementTypeName(DataTypes.DTYPE_CHARACTER_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_CHARACTER_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_CHAR) || tokens.matches(DataTypes.DTYPE_CHARACTER)) { dataType = new DataType(); typeName = consume(tokens, dataType, false); // "CHARACTER", "CHAR", dataType.setName(typeName); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } @@ -359,48 +359,48 @@ public class DataTypeParser implements DdlConstants { typeName = getStatementTypeName(DataTypes.DTYPE_NCHAR_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NCHAR_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_NATIONAL_CHAR_VARYING)) { typeName = getStatementTypeName(DataTypes.DTYPE_NATIONAL_CHAR_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NATIONAL_CHAR_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_NATIONAL_CHARACTER_VARYING)) { typeName = getStatementTypeName(DataTypes.DTYPE_NATIONAL_CHARACTER_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NATIONAL_CHARACTER_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_NCHAR)) { typeName = getStatementTypeName(DataTypes.DTYPE_NCHAR); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NCHAR); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_NATIONAL_CHAR)) { typeName = getStatementTypeName(DataTypes.DTYPE_NATIONAL_CHAR); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NATIONAL_CHAR); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_NATIONAL_CHARACTER)) { typeName = getStatementTypeName(DataTypes.DTYPE_NATIONAL_CHARACTER); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_NATIONAL_CHARACTER); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } @@ -424,16 +424,16 @@ public class DataTypeParser implements DdlConstants { typeName = getStatementTypeName(DataTypes.DTYPE_BIT_VARYING); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_BIT_VARYING); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setLength(length); } else if (tokens.matches(DataTypes.DTYPE_BIT)) { typeName = getStatementTypeName(DataTypes.DTYPE_BIT); dataType = new DataType(typeName); consume(tokens, dataType, false, DataTypes.DTYPE_BIT); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } @@ -468,9 +468,9 @@ public class DataTypeParser implements DdlConstants { if (tokens.matches(L_PAREN)) { consume(tokens, dataType, false, L_PAREN); - precision = parseInteger(tokens, dataType); + precision = (int)parseLong(tokens, dataType); if (canConsume(tokens, dataType, false, COMMA)) { - scale = parseInteger(tokens, dataType); + scale = (int)parseLong(tokens, dataType); } else { scale = getDefaultScale(); } @@ -512,7 +512,7 @@ public class DataTypeParser implements DdlConstants { dataType.setName(typeName); int precision = 0; if (tokens.matches(L_PAREN)) { - precision = parseBracketedInteger(tokens, dataType); + precision = (int)parseBracketedLong(tokens, dataType); } dataType.setPrecision(precision); } @@ -543,7 +543,7 @@ public class DataTypeParser implements DdlConstants { int precision = 0; if (tokens.matches(L_PAREN)) { - precision = parseBracketedInteger(tokens, dataType); + precision = (int)parseBracketedLong(tokens, dataType); } dataType.setPrecision(precision); @@ -555,7 +555,7 @@ public class DataTypeParser implements DdlConstants { int precision = 0; if (tokens.matches(L_PAREN)) { - precision = parseBracketedInteger(tokens, dataType); + precision = (int)parseBracketedLong(tokens, dataType); } dataType.setPrecision(precision); @@ -683,48 +683,31 @@ public class DataTypeParser implements DdlConstants { } /** - * Returns an integer value from the input token stream assuming the integer is not bracketed with parenthesis. + * Returns a long value from the input token stream assuming the long is not bracketed with parenthesis. * * @param tokens * @param dataType - * @return integer value + * @return the long value */ - protected int parseInteger( DdlTokenStream tokens, - DataType dataType ) { + protected long parseLong( DdlTokenStream tokens, + DataType dataType ) { String value = consume(tokens, dataType, false); - - if (isKMGInteger(value)) { - value = value.substring(0, value.length() - 1); - } - - return new BigInteger(value).intValue(); + return parseLong(value); } /** - * Returns an integer value from the input token stream assuming the integer is bracketed with parenthesis. Example: (255) + * Returns a long value from the input token stream assuming the long is bracketed with parenthesis. * * @param tokens * @param dataType - * @return integer value + * @return the long value */ - protected int parseBracketedInteger( DdlTokenStream tokens, - DataType dataType ) { + protected long parseBracketedLong( DdlTokenStream tokens, + DataType dataType ) { consume(tokens, dataType, false, L_PAREN); - int length = parseInteger(tokens, dataType); + String value = consume(tokens, dataType, false); consume(tokens, dataType, false, R_PAREN); - - return length; - } - - /** - * Returns the whether or not a tokenized string is a complex BLOB or CLOB length value ending in K, M or G. Example: BLOB - * (100M) or CLOB(64K) - * - * @param value - * @return true if value ends with M, K or G - */ - protected boolean isKMGInteger( String value ) { - return (value.endsWith("M") || value.endsWith("K") || value.endsWith("G")); + return parseLong(value); } /** @@ -734,26 +717,19 @@ public class DataTypeParser implements DdlConstants { * @return integer value * @throws NumberFormatException if a valid integer is not found */ - protected int parseInteger( String value ) { - if (isKMGInteger(value)) { + protected long parseLong( String value ) { + long factor = 1; + if (value.endsWith("K")) { + factor = KILO; + } else if (value.endsWith("M")) { + factor = MEGA; + } else if (value.endsWith("G")) { + factor = GIGA; + } + if (factor > 1) { value = value.substring(0, value.length() - 1); } - - return new BigInteger(value).intValue(); - } - - /** - * Returns the K, M or G string value of a tokenized complex BLOB or CLOB length value Example: BLOB (100M) or CLOB(64K) - * - * @param value - * @return K, M or G or NULL if not found. - */ - protected String getKMG( String value ) { - if (value.endsWith("M")) return "M"; - if (value.endsWith("K")) return "K"; - if (value.endsWith("G")) return "G"; - - return null; + return new BigInteger(value).longValue() * factor; } /** Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/derby/DerbyDdlParser.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/derby/DerbyDdlParser.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/derby/DerbyDdlParser.java (working copy) @@ -1260,18 +1260,6 @@ public class DerbyDdlParser extends StandardDdlParser implements DerbyDdlConstan /** * {@inheritDoc} * - * @see org.modeshape.sequencer.ddl.datatype.DataTypeParser#parseBracketedInteger(org.modeshape.sequencer.ddl.DdlTokenStream, - * org.modeshape.sequencer.ddl.datatype.DataType) - */ - @Override - protected int parseBracketedInteger( DdlTokenStream tokens, - DataType dataType ) { - return super.parseBracketedInteger(tokens, dataType); - } - - /** - * {@inheritDoc} - * * @see org.modeshape.sequencer.ddl.datatype.DataTypeParser#parseCharStringType(org.modeshape.sequencer.ddl.DdlTokenStream) */ @Override @@ -1292,50 +1280,30 @@ public class DerbyDdlParser extends StandardDdlParser implements DerbyDdlConstan protected DataType parseCustomType( DdlTokenStream tokens ) throws ParsingException { DataType dataType = null; String typeName = null; - int length = 0; + long length = 0; if (tokens.matches(DerbyDataTypes.DTYPE_BINARY_LARGE_OBJECT) || tokens.matches(DerbyDataTypes.DTYPE_CHARACTER_LARGE_OBJECT)) { dataType = new DataType(); typeName = consume(tokens, dataType, true) + SPACE + consume(tokens, dataType, true) + SPACE + consume(tokens, dataType, true); - boolean isKMGLength = false; - String kmgValue = null; if (canConsume(tokens, dataType, true, L_PAREN)) { String lengthValue = consume(tokens, dataType, false); - kmgValue = getKMG(lengthValue); - - isKMGLength = isKMGInteger(lengthValue); - - length = parseInteger(lengthValue); - + length = parseLong(lengthValue); consume(tokens, dataType, true, R_PAREN); } - dataType.setName(typeName); dataType.setLength(length); - dataType.setKMGLength(isKMGLength); - dataType.setKMGValue(kmgValue); } else if (tokens.matches(DerbyDataTypes.DTYPE_CLOB) || tokens.matches(DerbyDataTypes.DTYPE_BLOB)) { dataType = new DataType(); typeName = consume(tokens, dataType, true); - boolean isKMGLength = false; - String kmgValue = null; if (canConsume(tokens, dataType, true, L_PAREN)) { String lengthValue = consume(tokens, dataType, false); - kmgValue = getKMG(lengthValue); - - isKMGLength = isKMGInteger(lengthValue); - - length = parseInteger(lengthValue); - + length = parseLong(lengthValue); consume(tokens, dataType, true, R_PAREN); } - dataType.setName(typeName); dataType.setLength(length); - dataType.setKMGLength(isKMGLength); - dataType.setKMGValue(kmgValue); } else if (tokens.matches(DerbyDataTypes.DTYPE_BIGINT)) { dataType = new DataType(); typeName = consume(tokens, dataType, true); Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/mysql/MySqlDdlParser.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/mysql/MySqlDdlParser.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/mysql/MySqlDdlParser.java (working copy) @@ -590,12 +590,6 @@ public class MySqlDdlParser extends StandardDdlParser implements MySqlDdlConstan } @Override - protected int parseBracketedInteger( DdlTokenStream tokens, - DataType dataType ) { - return super.parseBracketedInteger(tokens, dataType); - } - - @Override protected DataType parseCharStringType( DdlTokenStream tokens ) throws ParsingException { DataType result = super.parseCharStringType(tokens); @@ -618,9 +612,9 @@ public class MySqlDdlParser extends StandardDdlParser implements MySqlDdlConstan if (tokens.matches(L_PAREN)) { consume(tokens, dataType, false, L_PAREN); - precision = parseInteger(tokens, dataType); + precision = (int)parseLong(tokens, dataType); if (tokens.canConsume(COMMA)) { - scale = parseInteger(tokens, dataType); + scale = (int)parseLong(tokens, dataType); } else { scale = getDefaultScale(); } @@ -640,18 +634,18 @@ public class MySqlDdlParser extends StandardDdlParser implements MySqlDdlConstan || tokens.matches(DTYPE_BINARY) || tokens.matches(DTYPE_BIGINT)) { String typeName = tokens.consume(); dataType = new DataType(typeName); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } else if (tokens.matches(DTYPE_NATIONAL_VARCHAR)) { String typeName = getStatementTypeName(DTYPE_NATIONAL_VARCHAR); dataType = new DataType(typeName); tokens.consume(DTYPE_NATIONAL_VARCHAR); - int length = getDefaultLength(); + long length = getDefaultLength(); if (tokens.matches(L_PAREN)) { - length = parseBracketedInteger(tokens, dataType); + length = parseBracketedLong(tokens, dataType); } dataType.setLength(length); } else if (tokens.matches(DTYPE_MEDIUMTEXT) || tokens.matches(DTYPE_TEXT) || tokens.matches(DTYPE_LONGTEXT) Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/oracle/OracleDdlParser.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/oracle/OracleDdlParser.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/oracle/OracleDdlParser.java (working copy) @@ -787,10 +787,10 @@ public class OracleDdlParser extends StandardDdlParser // tokens.matches(GRANT, "SELECT") || // tokens.matches(GRANT, "RESTRICTED") || // // - //======================================================================================================================== + // ======================================================================================================================== // === // // - //======================================================================================================================== + // ======================================================================================================================== // === // tokens.matches(GRANT, "FLASHBACK") || // tokens.matches(GRANT, "GLOBAL") || @@ -1517,7 +1517,7 @@ public class OracleDdlParser extends StandardDdlParser if (stopAtStatementStart) { while (tokens.hasNext() - && !tokens.matches(DdlTokenizer.STATEMENT_KEY) && !tokens.matches('/')) { //!tokens.matches(DdlTokenizer.STATEMENT_KEY + && !tokens.matches(DdlTokenizer.STATEMENT_KEY) && !tokens.matches('/')) { // !tokens.matches(DdlTokenizer.STATEMENT_KEY // ) // && sb.append(SPACE).append(tokens.consume()); @@ -1610,7 +1610,7 @@ public class OracleDdlParser extends StandardDdlParser // VARCHAR2(size [BYTE | CHAR]) typeName = consume(tokens, dataType, true, OracleDataTypes.DTYPE_VARCHAR2); // VARCHAR2 consume(tokens, dataType, false, L_PAREN); - int length = parseInteger(tokens, dataType); + long length = parseLong(tokens, dataType); canConsume(tokens, dataType, true, "BYTE"); canConsume(tokens, dataType, true, "CHAR"); consume(tokens, dataType, false, R_PAREN); @@ -1619,13 +1619,13 @@ public class OracleDdlParser extends StandardDdlParser } else if (tokens.matches(OracleDataTypes.DTYPE_RAW)) { dataType = new DataType(); typeName = consume(tokens, dataType, true, OracleDataTypes.DTYPE_RAW); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setName(typeName); dataType.setLength(length); } else if (tokens.matches(OracleDataTypes.DTYPE_NVARCHAR2)) { dataType = new DataType(); typeName = consume(tokens, dataType, true, OracleDataTypes.DTYPE_NVARCHAR2); - int length = parseBracketedInteger(tokens, dataType); + long length = parseBracketedLong(tokens, dataType); dataType.setName(typeName); dataType.setLength(length); } else if (tokens.matches(OracleDataTypes.DTYPE_NUMBER)) { @@ -1635,9 +1635,9 @@ public class OracleDdlParser extends StandardDdlParser int scale = 0; if (tokens.matches(L_PAREN)) { consume(tokens, dataType, false, L_PAREN); - precision = parseInteger(tokens, dataType); + precision = (int)parseLong(tokens, dataType); if (canConsume(tokens, dataType, false, COMMA)) { - scale = parseInteger(tokens, dataType); + scale = (int)parseLong(tokens, dataType); } else { scale = getDefaultScale(); } @@ -1677,7 +1677,7 @@ public class OracleDdlParser extends StandardDdlParser dataType = new DataType(); String typeName = consume(tokens, dataType, true, OracleDataTypes.DTYPE_CHAR_ORACLE); consume(tokens, dataType, false, L_PAREN); - int length = parseInteger(tokens, dataType); + long length = parseLong(tokens, dataType); canConsume(tokens, dataType, true, "BYTE"); canConsume(tokens, dataType, true, "CHAR"); consume(tokens, dataType, false, R_PAREN); Index: extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/postgres/PostgresDdlParser.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/postgres/PostgresDdlParser.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/main/java/org/modeshape/sequencer/ddl/dialect/postgres/PostgresDdlParser.java (working copy) @@ -1738,7 +1738,7 @@ public class PostgresDdlParser extends StandardDdlParser result = new DataType(typeName); int precision = 0; if (tokens.matches('(')) { - precision = parseBracketedInteger(tokens, result); + precision = (int)parseBracketedLong(tokens, result); } result.setPrecision(precision); } @@ -1763,18 +1763,6 @@ public class PostgresDdlParser extends StandardDdlParser /** * {@inheritDoc} * - * @see org.modeshape.sequencer.ddl.datatype.DataTypeParser#parseBracketedInteger(org.modeshape.sequencer.ddl.DdlTokenStream, - * org.modeshape.sequencer.ddl.datatype.DataType) - */ - @Override - protected int parseBracketedInteger( DdlTokenStream tokens, - DataType dataType ) { - return super.parseBracketedInteger(tokens, dataType); - } - - /** - * {@inheritDoc} - * * @see org.modeshape.sequencer.ddl.datatype.DataTypeParser#parseCharStringType(org.modeshape.sequencer.ddl.DdlTokenStream) */ @Override Index: extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/StandardDdlParserTest.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/StandardDdlParserTest.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/StandardDdlParserTest.java (working copy) @@ -61,6 +61,7 @@ import java.util.List; import org.junit.After; import org.junit.Before; import org.junit.Test; +import org.modeshape.common.FixFor; import org.modeshape.graph.JcrLexicon; import org.modeshape.sequencer.ddl.node.AstNode; @@ -366,7 +367,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals(1, tableNode.getChildCount()); AstNode column = tableNode.getChildren().get(0); assertEquals("VARCHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); assertEquals(DEFAULT_ID_LITERAL, column.getProperty(DEFAULT_OPTION).getFirstValue()); @@ -384,7 +385,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals(1, tableNode.getChildCount()); column = tableNode.getChildren().get(0); assertEquals("CHARACTER", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); assertEquals("NULL", column.getProperty(NULLABLE).getFirstValue()); assertEquals(DEFAULT_ID_LITERAL, column.getProperty(DEFAULT_OPTION).getFirstValue()); @@ -409,6 +410,75 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals("6.213", column.getProperty(DEFAULT_VALUE).getFirstValue()); } + @FixFor( "MODE-820" ) + @Test + public void shouldParseColumnDefinitionWithKilobyteInSize() { + printTest("shouldParseColumnDefinitionWithKilobyteInSize()"); + + String content = "PARTID CHAR(2K) NOT NULL"; + + DdlTokenStream tokens = getTokens(content); + + AstNode tableNode = parser.nodeFactory().node("PARTID", rootNode, TYPE_CREATE_TABLE_STATEMENT, rootNode); + parser.setRootNode(rootNode); + parser.parseColumnDefinition(tokens, tableNode, false); + + assertEquals(1, tableNode.getChildCount()); + AstNode column = tableNode.getChildren().get(0); + assertEquals("CHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); + assertEquals(2048L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertTrue(column.getProperty(DATATYPE_PRECISION) == null); + assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); + + tableNode.removeAllChildren(); + } + + @FixFor( "MODE-820" ) + @Test + public void shouldParseColumnDefinitionWithMegabyteInSize() { + printTest("shouldParseColumnDefinitionWithKilobyteInSize()"); + + String content = "PARTID CHAR(4M) NOT NULL"; + + DdlTokenStream tokens = getTokens(content); + + AstNode tableNode = parser.nodeFactory().node("PARTID", rootNode, TYPE_CREATE_TABLE_STATEMENT, rootNode); + parser.setRootNode(rootNode); + parser.parseColumnDefinition(tokens, tableNode, false); + + assertEquals(1, tableNode.getChildCount()); + AstNode column = tableNode.getChildren().get(0); + assertEquals("CHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); + assertEquals(4194304L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertTrue(column.getProperty(DATATYPE_PRECISION) == null); + assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); + + tableNode.removeAllChildren(); + } + + @FixFor( "MODE-820" ) + @Test + public void shouldParseColumnDefinitionWithGigabyteInSize() { + printTest("shouldParseColumnDefinitionWithKilobyteInSize()"); + + String content = "PARTID CHAR(5G) NOT NULL"; + + DdlTokenStream tokens = getTokens(content); + + AstNode tableNode = parser.nodeFactory().node("PARTID", rootNode, TYPE_CREATE_TABLE_STATEMENT, rootNode); + parser.setRootNode(rootNode); + parser.parseColumnDefinition(tokens, tableNode, false); + + assertEquals(1, tableNode.getChildCount()); + AstNode column = tableNode.getChildren().get(0); + assertEquals("CHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); + assertEquals(5368709120L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertTrue(column.getProperty(DATATYPE_PRECISION) == null); + assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); + + tableNode.removeAllChildren(); + } + @Test public void shouldGetTableElementString() { printTest("shouldGetTableElementString()"); @@ -444,7 +514,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { AstNode column = tableNode.getChildren().get(0); assertEquals("PARTID", column.getName().getString()); assertEquals("VARCHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); List tableOptions = parser.nodeFactory().getChildrenForType(tableNode, TYPE_STATEMENT_OPTION); @@ -453,6 +523,41 @@ public class StandardDdlParserTest extends DdlParserTestHelper { } + @FixFor( "MODE-820" ) + @Test + public void shouldParseCreateTableWithKilobyteInSize() { + printTest("shouldParseCreateTable()"); + + String content = "CREATE TABLE MY_TABLE_A (PARTID CHAR (2K) NOT NULL, " + + " -- COLUMN 1 COMMENT with comma \nPARTCOLOR CHAR(4M) NOT NULL) ON COMMIT DELETE ROWS;"; + + DdlTokenStream tokens = getTokens(content); + + parser.setRootNode(rootNode); + + AstNode result = parser.parseCreateTableStatement(tokens, rootNode); + + assertEquals(1, rootNode.getChildCount()); + AstNode tableNode = rootNode.getChildren().get(0); + assertThat(result, is(tableNode)); + assertEquals("MY_TABLE_A", tableNode.getName().getString()); + assertEquals(3, tableNode.getChildCount()); // 2 COLUMNS + 1 Table Option + AstNode column1 = tableNode.getChildren().get(0); + assertEquals("PARTID", column1.getName().getString()); + assertEquals("CHAR", column1.getProperty(DATATYPE_NAME).getFirstValue()); + assertEquals(2048L, column1.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertTrue(column1.getProperty(DATATYPE_PRECISION) == null); + AstNode column2 = tableNode.getChildren().get(1); + assertEquals("PARTCOLOR", column2.getName().getString()); + assertEquals("CHAR", column2.getProperty(DATATYPE_NAME).getFirstValue()); + assertEquals(4194304L, column2.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertTrue(column2.getProperty(DATATYPE_PRECISION) == null); + + List tableOptions = parser.nodeFactory().getChildrenForType(tableNode, TYPE_STATEMENT_OPTION); + assertEquals(1, tableOptions.size()); + assertEquals("ON COMMIT DELETE ROWS", tableOptions.get(0).getProperty(VALUE).getFirstValue()); + } + @Test public void shouldParseNextTableOption() { printTest("shouldParseNextTableOption()"); @@ -597,7 +702,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { AstNode column = parser.nodeFactory().getChildforNameAndType(tableNode, "PART_COLOR", TYPE_COLUMN_DEFINITION); assertNotNull(column); assertEquals("VARCHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); assertTrue(column.getProperty(DATATYPE_SCALE) == null); assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); @@ -628,7 +733,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals(2, tableNode.getChildCount()); AstNode column = tableNode.getChildren().get(0); assertEquals("VARCHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); assertEquals("NOT NULL", column.getProperty(NULLABLE).getFirstValue()); assertEquals(DEFAULT_ID_LITERAL, column.getProperty(DEFAULT_OPTION).getFirstValue()); @@ -653,7 +758,7 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals(4, tableNode.getChildCount()); // 2 COLUMNs + 2 PRIMARY KEY CONSTRAINTS (BOGUS) AstNode column1 = tableNode.getChildren().get(0); assertEquals("VARCHAR", column1.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column1.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column1.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column1.getProperty(DATATYPE_PRECISION) == null); } @@ -675,10 +780,10 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals(2, tableNode.getChildCount()); // 1 COLUMN & 1 CONSTRAINT AstNode column = tableNode.getChildren().get(0); assertEquals("VARCHAR", column.getProperty(DATATYPE_NAME).getFirstValue()); - assertEquals(255, column.getProperty(DATATYPE_LENGTH).getFirstValue()); + assertEquals(255L, column.getProperty(DATATYPE_LENGTH).getFirstValue()); assertTrue(column.getProperty(DATATYPE_PRECISION) == null); } - + @Test public void shouldParseCreateTableWithInlineUniqueConstraint() { printTest("shouldParseCreateTableWithInlineUniqueConstraint()"); @@ -699,12 +804,12 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals("NUMERIC", column.getProperty(DATATYPE_NAME).getFirstValue()); assertEquals(10, column.getProperty(DATATYPE_PRECISION).getFirstValue()); assertTrue(column.getProperty(DATATYPE_LENGTH) == null); - + AstNode prim_key = tableNode.getChildren().get(1); AstNode columnRef = prim_key.getChildren().get(0); assertEquals("REALMUID", columnRef.getName().getString()); } - + @Test public void shouldParseCreateTableWithInlineUniqueConstraintWithColumns() { printTest("shouldParseCreateTableWithInlineUniqueConstraint()"); @@ -725,13 +830,12 @@ public class StandardDdlParserTest extends DdlParserTestHelper { assertEquals("NUMERIC", column.getProperty(DATATYPE_NAME).getFirstValue()); assertEquals(10, column.getProperty(DATATYPE_PRECISION).getFirstValue()); assertTrue(column.getProperty(DATATYPE_LENGTH) == null); - + AstNode prim_key = tableNode.getChildren().get(1); assertEquals(2, prim_key.getChildCount()); // 2 column references AstNode columnRef = prim_key.getChildren().get(0); assertEquals("columnA", columnRef.getName().getString()); } - @Test public void shouldParseCreateTables() { Index: extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/datatype/DataTypeParserTest.java =================================================================== --- extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/datatype/DataTypeParserTest.java (revision 2005) +++ extensions/modeshape-sequencer-ddl/src/test/java/org/modeshape/sequencer/ddl/datatype/DataTypeParserTest.java (working copy) @@ -1,786 +1,770 @@ package org.modeshape.sequencer.ddl.datatype; -import org.modeshape.common.text.ParsingException; -import org.modeshape.sequencer.ddl.DdlConstants; -import org.modeshape.sequencer.ddl.DdlTokenStream; - import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.modeshape.common.text.ParsingException; +import org.modeshape.sequencer.ddl.DdlConstants; +import org.modeshape.sequencer.ddl.DdlTokenStream; public class DataTypeParserTest implements DdlConstants { - private DataTypeParser parser; + private DataTypeParser parser; + + private boolean printTest = false; - private boolean printTest = false; - @Before public void beforeEach() { - parser = new DataTypeParser(); - } - - private DdlTokenStream getTokens(String content) { - DdlTokenStream tokens = new DdlTokenStream(content, DdlTokenStream.ddlTokenizer(false), false); - - tokens.start(); - - return tokens; - } - - private String getDataTypeString(String[] input) { - StringBuffer sb = new StringBuffer(); - - for(int i=0; i0 ) { - sb.append(SPACE); - } - sb.append(input[i]); - } - - return sb.toString(); - } - - private void printTest(String value) { - if( printTest ) { - System.out.println("TEST: " + value); - } - } - -// private void printResult(String value) { -// if( printTest ) { -// System.out.println(value); -// } -// } + parser = new DataTypeParser(); + } + + private DdlTokenStream getTokens( String content ) { + DdlTokenStream tokens = new DdlTokenStream(content, DdlTokenStream.ddlTokenizer(false), false); + + tokens.start(); + + return tokens; + } + + private String getDataTypeString( String[] input ) { + StringBuffer sb = new StringBuffer(); + + for (int i = 0; i < input.length; i++) { + if (i > 0) { + sb.append(SPACE); + } + sb.append(input[i]); + } + + return sb.toString(); + } + + private void printTest( String value ) { + if (printTest) { + System.out.println("TEST: " + value); + } + } + + // private void printResult(String value) { + // if( printTest ) { + // System.out.println(value); + // } + // } /* =========================================================================================================================== * UTILITY METHODS * ========================================================================================================================== */ - + @Test public void shouldParseBracketedInteger() { - printTest("shouldParseBracketedInteger()"); - String content = "(255)"; - DdlTokenStream tokens = getTokens(content); - int value = parser.parseBracketedInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 255, value); - } - + printTest("shouldParseBracketedInteger()"); + String content = "(255)"; + DdlTokenStream tokens = getTokens(content); + long value = parser.parseBracketedLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 255, value); + } + @Test public void shouldParseKMGInteger() { - printTest("shouldParseKMGInteger()"); - String content = "1000M"; - DdlTokenStream tokens = getTokens(content); - - int value = parser.parseInteger(tokens, new DataType()); - Assert.assertEquals("DataType length is not correct", 1000, value); - - content = "1000G"; - tokens = getTokens(content); - value = parser.parseInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 1000, value); - - content = "1000K"; - tokens = getTokens(content); - value = parser.parseInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 1000, value); - - content = "(1000M)"; - tokens = getTokens(content); - value = parser.parseBracketedInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 1000, value); - - content = "(1000G)"; - tokens = getTokens(content); - value = parser.parseBracketedInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 1000, value); - - content = "(1000K)"; - tokens = getTokens(content); - value = parser.parseBracketedInteger(tokens, new DataType()); - - Assert.assertEquals("DataType length is not correct", 1000, value); - } - + printTest("shouldParseKMGInteger()"); + String content = "1000M"; + DdlTokenStream tokens = getTokens(content); + + long value = parser.parseLong(tokens, new DataType()); + Assert.assertEquals("DataType length is not correct", 1000 * MEGA, value); + + content = "1000G"; + tokens = getTokens(content); + value = parser.parseLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 1000 * GIGA, value); + + content = "1000K"; + tokens = getTokens(content); + value = parser.parseLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 1000 * KILO, value); + + content = "(1000M)"; + tokens = getTokens(content); + value = parser.parseBracketedLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 1000 * MEGA, value); + + content = "(1000G)"; + tokens = getTokens(content); + value = parser.parseBracketedLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 1000 * GIGA, value); + + content = "(1000K)"; + tokens = getTokens(content); + value = parser.parseBracketedLong(tokens, new DataType()); + + Assert.assertEquals("DataType length is not correct", 1000 * KILO, value); + } + /* =========================================================================================================================== * CHARACTER STRING TYPE * ========================================================================================================================== - ::= - CHARACTER [ ] - | CHAR [ ] - | CHARACTER VARYING - | CHAR VARYING - | VARCHAR + ::= + CHARACTER [ ] + | CHAR [ ] + | CHARACTER VARYING + | CHAR VARYING + | VARCHAR */ - - @Test - public void shouldParseCHAR() { - printTest("shouldParseCHAR()"); - String typeString = getDataTypeString(DataTypes.DTYPE_CHAR); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (255)"; - tokens = getTokens(content); - - dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseCHARACTER() { - printTest("shouldParseCHARACTER()"); - String typeString = getDataTypeString(DataTypes.DTYPE_CHARACTER); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (255)"; - tokens = getTokens(content); - - dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseCHAR_VARYING() { - printTest("shouldParseCHAR_VARYING()"); - String typeString = getDataTypeString(DataTypes.DTYPE_CHAR_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseCHARACTER_VARYING() { - printTest("shouldParseCHARACTER_VARYING()"); - String typeString = getDataTypeString(DataTypes.DTYPE_CHARACTER_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseVARCHAR() { - printTest("shouldParseVARCHAR()"); - String typeString = getDataTypeString(DataTypes.DTYPE_VARCHAR); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - - content = typeString; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - + + @Test + public void shouldParseCHAR() { + printTest("shouldParseCHAR()"); + String typeString = getDataTypeString(DataTypes.DTYPE_CHAR); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (255)"; + tokens = getTokens(content); + + dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseCHARACTER() { + printTest("shouldParseCHARACTER()"); + String typeString = getDataTypeString(DataTypes.DTYPE_CHARACTER); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (255)"; + tokens = getTokens(content); + + dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseCHAR_VARYING() { + printTest("shouldParseCHAR_VARYING()"); + String typeString = getDataTypeString(DataTypes.DTYPE_CHAR_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseCHARACTER_VARYING() { + printTest("shouldParseCHARACTER_VARYING()"); + String typeString = getDataTypeString(DataTypes.DTYPE_CHARACTER_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseVARCHAR() { + printTest("shouldParseVARCHAR()"); + String typeString = getDataTypeString(DataTypes.DTYPE_VARCHAR); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + + content = typeString; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + /* =========================================================================================================================== * NATIONAL CHARACTER STRING TYPE * ========================================================================================================================== * * - ::= - NATIONAL CHARACTER [ ] - | NATIONAL CHAR [ ] - | NCHAR [ ] - | NATIONAL CHARACTER VARYING - | NATIONAL CHAR VARYING - | NCHAR VARYING + ::= + NATIONAL CHARACTER [ ] + | NATIONAL CHAR [ ] + | NCHAR [ ] + | NATIONAL CHARACTER VARYING + | NATIONAL CHAR VARYING + | NCHAR VARYING * * */ - @Test - public void shouldParseNATIONAL_CHAR() { - printTest("shouldParseNATIONAL_CHAR()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHAR); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (255)"; - tokens = getTokens(content); - - dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseNATIONAL_CHARACTER() { - printTest("shouldParseNATIONAL_CHARACTER()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHARACTER); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (255)"; - tokens = getTokens(content); - - dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseNATIONAL_CHAR_VARYING() { - printTest("shouldParseNATIONAL_CHAR_VARYING()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHAR_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseNATIONAL_CHARACTER_VARYING() { - printTest("shouldParseNATIONAL_CHARACTER_VARYING()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHARACTER_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseNCHAR_VARYING() { - printTest("shouldParseNCHAR_VARYING()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NCHAR_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - - content = typeString; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - - + @Test + public void shouldParseNATIONAL_CHAR() { + printTest("shouldParseNATIONAL_CHAR()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHAR); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (255)"; + tokens = getTokens(content); + + dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseNATIONAL_CHARACTER() { + printTest("shouldParseNATIONAL_CHARACTER()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHARACTER); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (255)"; + tokens = getTokens(content); + + dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseNATIONAL_CHAR_VARYING() { + printTest("shouldParseNATIONAL_CHAR_VARYING()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHAR_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseNATIONAL_CHARACTER_VARYING() { + printTest("shouldParseNATIONAL_CHARACTER_VARYING()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NATIONAL_CHARACTER_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseNCHAR_VARYING() { + printTest("shouldParseNCHAR_VARYING()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NCHAR_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + + content = typeString; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + /* =========================================================================================================================== * NATIONAL CHARACTER STRING TYPE * ========================================================================================================================== * - ::= - BIT [ ] - | BIT VARYING + ::= + BIT [ ] + | BIT VARYING * */ - - @Test - public void shouldParseBIT() { - printTest("shouldParseBIT()"); - String typeString = getDataTypeString(DataTypes.DTYPE_BIT); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - - @Test - public void shouldParseBITWithLength() { - printTest("shouldParseBITWithLength()"); - String typeString = getDataTypeString(DataTypes.DTYPE_BIT); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - } - - @Test - public void shouldParseBIT_VARYINGWithLength() { - printTest("shouldParseBIT_VARYINGWithLength()"); - String typeString = getDataTypeString(DataTypes.DTYPE_BIT_VARYING); - String content = typeString + " (255)"; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); - - content = typeString; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - + + @Test + public void shouldParseBIT() { + printTest("shouldParseBIT()"); + String typeString = getDataTypeString(DataTypes.DTYPE_BIT); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + + @Test + public void shouldParseBITWithLength() { + printTest("shouldParseBITWithLength()"); + String typeString = getDataTypeString(DataTypes.DTYPE_BIT); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + } + + @Test + public void shouldParseBIT_VARYINGWithLength() { + printTest("shouldParseBIT_VARYINGWithLength()"); + String typeString = getDataTypeString(DataTypes.DTYPE_BIT_VARYING); + String content = typeString + " (255)"; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 255, dType.getLength()); + + content = typeString; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + /* =========================================================================================================================== * EXACT NUMERIC TYPE * ========================================================================================================================== - ::= - NUMERIC [ [ ] ] - | DECIMAL [ [ ] ] - | DEC [ [ ] ] - | INTEGER - | INT - | SMALLINT + ::= + NUMERIC [ [ ] ] + | DECIMAL [ [ ] ] + | DEC [ [ ] ] + | INTEGER + | INT + | SMALLINT * */ - - @Test - public void shouldNotParseXXXXXXTYPE() { - printTest("shouldNotParseXXXXXXTYPE()"); - String typeString = "XXXXXXTYPE"; - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - - DataType dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - - Assert.assertNull("DataType should NOT have been found for Type = " + typeString, dType); - } - - @Test - public void shouldParseINT() { - printTest("shouldParseINT()"); - String typeString = getDataTypeString(DataTypes.DTYPE_INT); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - - @Test - public void shouldParseINTEGER() { - printTest("shouldParseINTEGER()"); - String typeString = getDataTypeString(DataTypes.DTYPE_INTEGER); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - - @Test - public void shouldParseSMALLINT() { - printTest("shouldParseSMALLINT()"); - String typeString = getDataTypeString(DataTypes.DTYPE_SMALLINT); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - - @Test - public void shouldParseNUMERIC() { - printTest("shouldParseNUMERIC()"); - String typeString = getDataTypeString(DataTypes.DTYPE_NUMERIC); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (5)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - - content = typeString + " (5, 2)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE - - - // MISSING COMMA - content = typeString + " (5 2)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - - - // INVALID Scale Integer - content = typeString + " (5 A)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - - - @Test - public void shouldParseDECIMAL() { - printTest("shouldParseDECIMAL()"); - String typeString = getDataTypeString(DataTypes.DTYPE_DECIMAL); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (5)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - - content = typeString + " (5, 2)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE - - // MISSING COMMA - content = typeString + " (5 2)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - - - // INVALID Scale Integer - content = typeString + " (5 A)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - - - @Test - public void shouldParseDEC() { - printTest("shouldParseDEC()"); - String typeString = getDataTypeString(DataTypes.DTYPE_DEC); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (5)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - - content = typeString + " (5, 2)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE - - - // MISSING COMMA - content = typeString + " (5 2)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - - - // INVALID Scale Integer - content = typeString + " (5 A)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - } - - + + @Test + public void shouldNotParseXXXXXXTYPE() { + printTest("shouldNotParseXXXXXXTYPE()"); + String typeString = "XXXXXXTYPE"; + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + + Assert.assertNull("DataType should NOT have been found for Type = " + typeString, dType); + } + + @Test + public void shouldParseINT() { + printTest("shouldParseINT()"); + String typeString = getDataTypeString(DataTypes.DTYPE_INT); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + + @Test + public void shouldParseINTEGER() { + printTest("shouldParseINTEGER()"); + String typeString = getDataTypeString(DataTypes.DTYPE_INTEGER); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + + @Test + public void shouldParseSMALLINT() { + printTest("shouldParseSMALLINT()"); + String typeString = getDataTypeString(DataTypes.DTYPE_SMALLINT); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + + @Test + public void shouldParseNUMERIC() { + printTest("shouldParseNUMERIC()"); + String typeString = getDataTypeString(DataTypes.DTYPE_NUMERIC); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (5)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + + content = typeString + " (5, 2)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE + + // MISSING COMMA + content = typeString + " (5 2)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + + // INVALID Scale Integer + content = typeString + " (5 A)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + + @Test + public void shouldParseDECIMAL() { + printTest("shouldParseDECIMAL()"); + String typeString = getDataTypeString(DataTypes.DTYPE_DECIMAL); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (5)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + + content = typeString + " (5, 2)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE + + // MISSING COMMA + content = typeString + " (5 2)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + + // INVALID Scale Integer + content = typeString + " (5 A)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + + @Test + public void shouldParseDEC() { + printTest("shouldParseDEC()"); + String typeString = getDataTypeString(DataTypes.DTYPE_DEC); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (5)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + + content = typeString + " (5, 2)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + Assert.assertEquals("DataType length is not correct", 2, dType.getScale()); // SCALE + + // MISSING COMMA + content = typeString + " (5 2)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + + // INVALID Scale Integer + content = typeString + " (5 A)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + } + /* =========================================================================================================================== * APPROXIMATE NUMERIC TYPE * ========================================================================================================================== * - ::= - FLOAT [ ] - | REAL - | DOUBLE PRECISION + ::= + FLOAT [ ] + | REAL + | DOUBLE PRECISION */ - - - - @Test - public void shouldParseFLOAT() { - printTest("shouldParseFLOAT()"); - String typeString = getDataTypeString(DataTypes.DTYPE_FLOAT); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - - content = typeString + " (5)"; - tokens = getTokens(content); - dType = parser.parse(tokens); - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION - - // ADDED SCALE - content = typeString + " (5, 2)"; - tokens = getTokens(content); - dType = null; - try { - dType = parser.parse(tokens); - } catch (ParsingException e) { - // Expect exception - } - Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); - - } - - @Test - public void shouldParseREAL() { - printTest("shouldParseREAL()"); - String typeString = getDataTypeString(DataTypes.DTYPE_REAL); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - - - @Test - public void shouldParseDOUBLE_PRECISION() { - printTest("shouldParseDOUBLE_PRECISION()"); - String typeString = getDataTypeString(DataTypes.DTYPE_DOUBLE_PRECISION); - String content = typeString; - - DdlTokenStream tokens = getTokens(content); - - DataType dType = parser.parse(tokens); - - Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); - Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); - } - + + @Test + public void shouldParseFLOAT() { + printTest("shouldParseFLOAT()"); + String typeString = getDataTypeString(DataTypes.DTYPE_FLOAT); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + + content = typeString + " (5)"; + tokens = getTokens(content); + dType = parser.parse(tokens); + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + Assert.assertEquals("DataType length is not correct", 5, dType.getPrecision()); // PRECISION + + // ADDED SCALE + content = typeString + " (5, 2)"; + tokens = getTokens(content); + dType = null; + try { + dType = parser.parse(tokens); + } catch (ParsingException e) { + // Expect exception + } + Assert.assertNull("DataType should NOT have been found for Type = " + content, dType); + + } + + @Test + public void shouldParseREAL() { + printTest("shouldParseREAL()"); + String typeString = getDataTypeString(DataTypes.DTYPE_REAL); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + + @Test + public void shouldParseDOUBLE_PRECISION() { + printTest("shouldParseDOUBLE_PRECISION()"); + String typeString = getDataTypeString(DataTypes.DTYPE_DOUBLE_PRECISION); + String content = typeString; + + DdlTokenStream tokens = getTokens(content); + + DataType dType = parser.parse(tokens); + + Assert.assertNotNull("DataType was NOT found for Type = " + typeString, dType); + Assert.assertEquals("Wrong DataType found", typeString, dType.getName()); + } + /* =========================================================================================================================== * APPROXIMATE NUMERIC TYPE * ========================================================================================================================== * - ::= - DATE - | TIME [