Datasets:

jitx

/

Methods2Test_java_unit_test_code

like 13

@Test public void doubleNestedRelativeChangeLog() throws Exception { final String doubleNestedFileName = "liquibase/parser/core/xml/doubleNestedRelativeChangeLog.xml"; final String nestedFileName = "liquibase/parser/core/xml/nestedRelativeChangeLog.xml"; DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse(doubleNestedFileName, new ChangeLogParameters(), new JUnitResourceAccessor()); doubleNestedFileAssertions(doubleNestedFileName, nestedFileName, changeLog); }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void escapeTableName_withSchema() { Database database = getDatabase(); assertEquals("schemaName.tableName", database.escapeTableName("schemaName", "tableName")); }

public String escapeTableName(String schemaName, String tableName) { if (schemaName == null) { schemaName = getDefaultSchemaName(); } if (StringUtils.trimToNull(schemaName) == null || !supportsSchemas()) { return escapeDatabaseObject(tableName); } else { return escapeDatabaseObject(schemaName) + "." + escapeDatabaseObject(tableName); } }

AbstractDatabase implements Database { public String escapeTableName(String schemaName, String tableName) { if (schemaName == null) { schemaName = getDefaultSchemaName(); } if (StringUtils.trimToNull(schemaName) == null || !supportsSchemas()) { return escapeDatabaseObject(tableName); } else { return escapeDatabaseObject(schemaName) + "." + escapeDatabaseObject(tableName); } } }

AbstractDatabase implements Database { public String escapeTableName(String schemaName, String tableName) { if (schemaName == null) { schemaName = getDefaultSchemaName(); } if (StringUtils.trimToNull(schemaName) == null || !supportsSchemas()) { return escapeDatabaseObject(tableName); } else { return escapeDatabaseObject(schemaName) + "." + escapeDatabaseObject(tableName); } } protected AbstractDatabase(); }

AbstractDatabase implements Database { public String escapeTableName(String schemaName, String tableName) { if (schemaName == null) { schemaName = getDefaultSchemaName(); } if (StringUtils.trimToNull(schemaName) == null || !supportsSchemas()) { return escapeDatabaseObject(tableName); } else { return escapeDatabaseObject(schemaName) + "." + escapeDatabaseObject(tableName); } } protected AbstractDatabase(); boolean requiresPassword(); boolean requiresUsername(); DatabaseObject[] getContainingObjects(); DatabaseConnection getConnection(); void setConnection(DatabaseConnection conn); boolean getAutoCommitMode(); boolean supportsDDLInTransaction(); String getDatabaseProductName(); String getDatabaseProductVersion(); int getDatabaseMajorVersion(); int getDatabaseMinorVersion(); String getDefaultCatalogName(); String getDefaultSchemaName(); void setDefaultSchemaName(String schemaName); boolean supportsSequences(); boolean supportsAutoIncrement(); void setCurrentDateTimeFunction(String function); String getDateLiteral(String isoDate); String getDateTimeLiteral(java.sql.Timestamp date); String getDateLiteral(java.sql.Date date); String getTimeLiteral(java.sql.Time date); String getDateLiteral(Date date); Date parseDate(String dateAsString); String getLineComment(); String getAutoIncrementClause(BigInteger startWith, BigInteger incrementBy); String getConcatSql(String... values); String getDatabaseChangeLogTableName(); String getDatabaseChangeLogLockTableName(); void setDatabaseChangeLogTableName(String tableName); void setDatabaseChangeLogLockTableName(String tableName); void checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String... contexts); void setCanCacheLiquibaseTableInfo(boolean canCacheLiquibaseTableInfo); boolean hasDatabaseChangeLogTable(); boolean hasDatabaseChangeLogLockTable(); String getLiquibaseSchemaName(); void checkDatabaseChangeLogLockTable(); boolean isReservedWord(String string); void dropDatabaseObjects(String schema); boolean supportsDropTableCascadeConstraints(); boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean isSystemView(String catalogName, String schemaName, String viewName); boolean isLiquibaseTable(String tableName); void tag(String tagString); boolean doesTagExist(String tag); @Override String toString(); boolean shouldQuoteValue(String value); String getViewDefinition(String schemaName, String viewName); String escapeTableName(String schemaName, String tableName); String escapeDatabaseObject(String objectName); String escapeIndexName(String schemaName, String indexName); String escapeSequenceName(String schemaName, String sequenceName); String escapeConstraintName(String constraintName); String escapeColumnName(String schemaName, String tableName, String columnName); String escapeColumnNameList(String columnNames); String convertRequestedSchemaToCatalog(String requestedSchema); String convertRequestedSchemaToSchema(String requestedSchema); boolean supportsSchemas(); String generatePrimaryKeyName(String tableName); String escapeViewName(String schemaName, String viewName); ChangeSet.RunStatus getRunStatus(ChangeSet changeSet); RanChangeSet getRanChangeSet(ChangeSet changeSet); List<RanChangeSet> getRanChangeSetList(); Date getRanDate(ChangeSet changeSet); void markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType); void removeRanStatus(ChangeSet changeSet); String escapeStringForDatabase(String string); void commit(); void rollback(); @Override boolean equals(Object o); @Override int hashCode(); void close(); boolean supportsRestrictForeignKeys(); boolean isAutoCommit(); void setAutoCommit(boolean b); boolean isLocalDatabase(); void executeStatements(Change change, DatabaseChangeLog changeLog, List<SqlVisitor> sqlVisitors); void execute(SqlStatement[] statements, List<SqlVisitor> sqlVisitors); void saveStatements(Change change, List<SqlVisitor> sqlVisitors, Writer writer); void executeRollbackStatements(Change change, List<SqlVisitor> sqlVisitors); void saveRollbackStatement(Change change, List<SqlVisitor> sqlVisitors, Writer writer); int getNextChangeSetSequenceValue(); Table getTable(String schemaName, String tableName); List<DatabaseFunction> getDatabaseFunctions(); void reset(); boolean supportsForeignKeyDisable(); boolean disableForeignKeyChecks(); void enableForeignKeyChecks(); }

AbstractDatabase implements Database { public String escapeTableName(String schemaName, String tableName) { if (schemaName == null) { schemaName = getDefaultSchemaName(); } if (StringUtils.trimToNull(schemaName) == null || !supportsSchemas()) { return escapeDatabaseObject(tableName); } else { return escapeDatabaseObject(schemaName) + "." + escapeDatabaseObject(tableName); } } protected AbstractDatabase(); boolean requiresPassword(); boolean requiresUsername(); DatabaseObject[] getContainingObjects(); DatabaseConnection getConnection(); void setConnection(DatabaseConnection conn); boolean getAutoCommitMode(); boolean supportsDDLInTransaction(); String getDatabaseProductName(); String getDatabaseProductVersion(); int getDatabaseMajorVersion(); int getDatabaseMinorVersion(); String getDefaultCatalogName(); String getDefaultSchemaName(); void setDefaultSchemaName(String schemaName); boolean supportsSequences(); boolean supportsAutoIncrement(); void setCurrentDateTimeFunction(String function); String getDateLiteral(String isoDate); String getDateTimeLiteral(java.sql.Timestamp date); String getDateLiteral(java.sql.Date date); String getTimeLiteral(java.sql.Time date); String getDateLiteral(Date date); Date parseDate(String dateAsString); String getLineComment(); String getAutoIncrementClause(BigInteger startWith, BigInteger incrementBy); String getConcatSql(String... values); String getDatabaseChangeLogTableName(); String getDatabaseChangeLogLockTableName(); void setDatabaseChangeLogTableName(String tableName); void setDatabaseChangeLogLockTableName(String tableName); void checkDatabaseChangeLogTable(boolean updateExistingNullChecksums, DatabaseChangeLog databaseChangeLog, String... contexts); void setCanCacheLiquibaseTableInfo(boolean canCacheLiquibaseTableInfo); boolean hasDatabaseChangeLogTable(); boolean hasDatabaseChangeLogLockTable(); String getLiquibaseSchemaName(); void checkDatabaseChangeLogLockTable(); boolean isReservedWord(String string); void dropDatabaseObjects(String schema); boolean supportsDropTableCascadeConstraints(); boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean isSystemView(String catalogName, String schemaName, String viewName); boolean isLiquibaseTable(String tableName); void tag(String tagString); boolean doesTagExist(String tag); @Override String toString(); boolean shouldQuoteValue(String value); String getViewDefinition(String schemaName, String viewName); String escapeTableName(String schemaName, String tableName); String escapeDatabaseObject(String objectName); String escapeIndexName(String schemaName, String indexName); String escapeSequenceName(String schemaName, String sequenceName); String escapeConstraintName(String constraintName); String escapeColumnName(String schemaName, String tableName, String columnName); String escapeColumnNameList(String columnNames); String convertRequestedSchemaToCatalog(String requestedSchema); String convertRequestedSchemaToSchema(String requestedSchema); boolean supportsSchemas(); String generatePrimaryKeyName(String tableName); String escapeViewName(String schemaName, String viewName); ChangeSet.RunStatus getRunStatus(ChangeSet changeSet); RanChangeSet getRanChangeSet(ChangeSet changeSet); List<RanChangeSet> getRanChangeSetList(); Date getRanDate(ChangeSet changeSet); void markChangeSetExecStatus(ChangeSet changeSet, ChangeSet.ExecType execType); void removeRanStatus(ChangeSet changeSet); String escapeStringForDatabase(String string); void commit(); void rollback(); @Override boolean equals(Object o); @Override int hashCode(); void close(); boolean supportsRestrictForeignKeys(); boolean isAutoCommit(); void setAutoCommit(boolean b); boolean isLocalDatabase(); void executeStatements(Change change, DatabaseChangeLog changeLog, List<SqlVisitor> sqlVisitors); void execute(SqlStatement[] statements, List<SqlVisitor> sqlVisitors); void saveStatements(Change change, List<SqlVisitor> sqlVisitors, Writer writer); void executeRollbackStatements(Change change, List<SqlVisitor> sqlVisitors); void saveRollbackStatement(Change change, List<SqlVisitor> sqlVisitors, Writer writer); int getNextChangeSetSequenceValue(); Table getTable(String schemaName, String tableName); List<DatabaseFunction> getDatabaseFunctions(); void reset(); boolean supportsForeignKeyDisable(); boolean disableForeignKeyChecks(); void enableForeignKeyChecks(); }

@Test public void windowsDelimiter() { String sql = "\n" + "\n" + "Select * from Test;\n" + "Update Test set field = 1"; String[] result = StringUtils.processMutliLineSQL(sql,true, true, ";"); assertEquals(2,result.length); assertEquals("Select * from Test",result[0]); assertEquals("Update Test set field = 1",result[1]); }

public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void missingChangeLog() throws Exception { try { @SuppressWarnings("unused") DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse("liquibase/changelog/parser/xml/missingChangeLog.xml", new ChangeLogParameters(), new JUnitResourceAccessor()); } catch (Exception e) { assertTrue(e instanceof ChangeLogParseException); assertEquals("liquibase/changelog/parser/xml/missingChangeLog.xml does not exist", e.getMessage()); } }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void malformedChangeLog() throws Exception { try { DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse("liquibase/parser/core/xml/malformedChangeLog.xml", new ChangeLogParameters(), new JUnitResourceAccessor()); } catch (Exception e) { assertTrue(e instanceof ChangeLogParseException); assertTrue(e.getMessage().startsWith("Error parsing line")); } }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void otherNamespaceAttributesChangeLog() throws Exception { DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse("liquibase/parser/core/xml/simpleChangeLog.xml", new ChangeLogParameters(), new JUnitResourceAccessor()); assertEquals("liquibase/parser/core/xml/simpleChangeLog.xml", changeLog.getLogicalFilePath()); assertEquals("liquibase/parser/core/xml/simpleChangeLog.xml", changeLog.getPhysicalFilePath()); assertEquals(0, changeLog.getPreconditions().getNestedPreconditions().size()); assertEquals(1, changeLog.getChangeSets().size()); ChangeSet changeSet = changeLog.getChangeSets().get(0); assertEquals("nvoxland", changeSet.getAuthor()); assertEquals("1", changeSet.getId()); assertEquals(1, changeSet.getChanges().size()); assertEquals("liquibase/parser/core/xml/simpleChangeLog.xml", changeSet.getFilePath()); assertEquals("Some comments go here", changeSet.getComments()); Change change = changeSet.getChanges().get(0); assertEquals("createTable", change.getChangeMetaData().getName()); assertTrue(change instanceof CreateTableChange); }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void rawSqlParameter() throws Exception { ChangeLogParameters params = new ChangeLogParameters(); params.set("tablename", "rawsql"); DatabaseChangeLog changeLog = new XMLChangeLogSAXParser().parse("liquibase/parser/core/xml/rawSqlParameters.xml", params, new JUnitResourceAccessor()); assertEquals("liquibase/parser/core/xml/rawSqlParameters.xml", changeLog.getLogicalFilePath()); assertEquals("liquibase/parser/core/xml/rawSqlParameters.xml", changeLog.getPhysicalFilePath()); assertEquals(1, changeLog.getChangeSets().size()); ChangeSet changeSet = changeLog.getChangeSets().get(0); assertEquals("paikens", changeSet.getAuthor()); assertEquals("1", changeSet.getId()); assertEquals("liquibase/parser/core/xml/rawSqlParameters.xml", changeSet.getFilePath()); assertEquals(1, changeSet.getChanges().size()); assertTrue(changeSet.getChanges().get(0) instanceof RawSQLChange); assertEquals("create table rawsql;", ((RawSQLChange) changeSet.getChanges().get(0)).getSql()); assertEquals(1, changeSet.getRollBackChanges().length); assertTrue(changeSet.getRollBackChanges()[0] instanceof RawSQLChange); assertEquals("drop table rawsql", ((RawSQLChange) changeSet.getRollBackChanges()[0]).getSql()); }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

XMLChangeLogSAXParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { InputStream inputStream = null; try { SAXParser parser = saxParserFactory.newSAXParser(); try { parser.setProperty("http: } catch (SAXNotRecognizedException e) { } catch (SAXNotSupportedException e) { } XMLReader xmlReader = parser.getXMLReader(); LiquibaseEntityResolver resolver=new LiquibaseEntityResolver(); resolver.useResoureAccessor(resourceAccessor,FilenameUtils.getFullPath(physicalChangeLogLocation)); xmlReader.setEntityResolver(resolver); xmlReader.setErrorHandler(new ErrorHandler() { public void warning(SAXParseException exception) throws SAXException { LogFactory.getLogger().warning(exception.getMessage()); throw exception; } public void error(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } public void fatalError(SAXParseException exception) throws SAXException { LogFactory.getLogger().severe(exception.getMessage()); throw exception; } }); inputStream = resourceAccessor.getResourceAsStream(physicalChangeLogLocation); if (inputStream == null) { throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist"); } XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters); xmlReader.setContentHandler(contentHandler); xmlReader.parse(new InputSource(inputStream)); return contentHandler.getDatabaseChangeLog(); } catch (ChangeLogParseException e) { throw e; } catch (IOException e) { throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e); } catch (SAXParseException e) { throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation +": " + e.getMessage(), e); } catch (SAXException e) { Throwable parentCause = e.getException(); while (parentCause != null) { if (parentCause instanceof ChangeLogParseException) { throw ((ChangeLogParseException) parentCause); } parentCause = parentCause.getCause(); } String reason = e.getMessage(); String causeReason = null; if (e.getCause() != null) { causeReason = e.getCause().getMessage(); } if (reason == null) { if (causeReason != null) { reason = causeReason; } else { reason = "Unknown Reason"; } } throw new ChangeLogParseException("Invalid Migration File: " + reason, e); } catch (Exception e) { throw new ChangeLogParseException(e); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { } } } } XMLChangeLogSAXParser(); int getPriority(); static String getSchemaVersion(); static String getDatabaseChangeLogNameSpace(); boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void resolveSchemas() throws Exception { LiquibaseEntityResolver liquibaseSchemaResolver = new LiquibaseEntityResolver(); assertNotNull(liquibaseSchemaResolver.resolveEntity(null, null, null, "http: assertNull(liquibaseSchemaResolver.resolveEntity(null,null,null, "http: }

public InputSource resolveEntity(String name, String publicId, String baseURI, String systemId) throws SAXException, IOException { InputSource resolved=null; if(systemId!=null && systemId.toLowerCase().endsWith(".xsd")) { resolved=tryResolveLiquibaseSchema(systemId, publicId); } if(resolved==null && resourceAccessor!=null && basePath!=null && systemId!=null) { resolved=tryResolveFromResourceAccessor(systemId); } return resolved; }

LiquibaseEntityResolver implements EntityResolver2 { public InputSource resolveEntity(String name, String publicId, String baseURI, String systemId) throws SAXException, IOException { InputSource resolved=null; if(systemId!=null && systemId.toLowerCase().endsWith(".xsd")) { resolved=tryResolveLiquibaseSchema(systemId, publicId); } if(resolved==null && resourceAccessor!=null && basePath!=null && systemId!=null) { resolved=tryResolveFromResourceAccessor(systemId); } return resolved; } }

LiquibaseEntityResolver implements EntityResolver2 { public InputSource resolveEntity(String name, String publicId, String baseURI, String systemId) throws SAXException, IOException { InputSource resolved=null; if(systemId!=null && systemId.toLowerCase().endsWith(".xsd")) { resolved=tryResolveLiquibaseSchema(systemId, publicId); } if(resolved==null && resourceAccessor!=null && basePath!=null && systemId!=null) { resolved=tryResolveFromResourceAccessor(systemId); } return resolved; } LiquibaseEntityResolver(); }

LiquibaseEntityResolver implements EntityResolver2 { public InputSource resolveEntity(String name, String publicId, String baseURI, String systemId) throws SAXException, IOException { InputSource resolved=null; if(systemId!=null && systemId.toLowerCase().endsWith(".xsd")) { resolved=tryResolveLiquibaseSchema(systemId, publicId); } if(resolved==null && resourceAccessor!=null && basePath!=null && systemId!=null) { resolved=tryResolveFromResourceAccessor(systemId); } return resolved; } LiquibaseEntityResolver(); void useResoureAccessor(ResourceAccessor resourceAccessor,String basePath); InputSource resolveEntity(String name, String publicId, String baseURI, String systemId); InputSource getExternalSubset(String name, String baseURI); InputSource resolveEntity(String publicId, String systemId); }

LiquibaseEntityResolver implements EntityResolver2 { public InputSource resolveEntity(String name, String publicId, String baseURI, String systemId) throws SAXException, IOException { InputSource resolved=null; if(systemId!=null && systemId.toLowerCase().endsWith(".xsd")) { resolved=tryResolveLiquibaseSchema(systemId, publicId); } if(resolved==null && resourceAccessor!=null && basePath!=null && systemId!=null) { resolved=tryResolveFromResourceAccessor(systemId); } return resolved; } LiquibaseEntityResolver(); void useResoureAccessor(ResourceAccessor resourceAccessor,String basePath); InputSource resolveEntity(String name, String publicId, String baseURI, String systemId); InputSource getExternalSubset(String name, String baseURI); InputSource resolveEntity(String publicId, String systemId); }

@Test public void supports() throws Exception { assertTrue(new MockFormattedSqlChangeLogParser(VALID_CHANGELOG).supports("asdf.sql", new JUnitResourceAccessor())); assertFalse(new MockFormattedSqlChangeLogParser(INVALID_CHANGELOG).supports("asdf.sql", new JUnitResourceAccessor())); }

public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } }

FormattedSqlChangeLogParser implements ChangeLogParser { public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } } }

FormattedSqlChangeLogParser implements ChangeLogParser { public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } } }

FormattedSqlChangeLogParser implements ChangeLogParser { public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

FormattedSqlChangeLogParser implements ChangeLogParser { public boolean supports(String changeLogFile, ResourceAccessor resourceAccessor) { BufferedReader reader = null; try { if (changeLogFile.endsWith(".sql")) { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(changeLogFile, resourceAccessor))); return reader.readLine().matches("\\-\\-\\s*liquibase formatted.*"); } else { return false; } } catch (IOException e) { LogFactory.getLogger().debug("Exception reading " + changeLogFile, e); return false; } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { LogFactory.getLogger().debug("Exception closing " + changeLogFile, e); } } } } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test(expected = ChangeLogParseException.class) public void invalidPrecondition() throws Exception{ new MockFormattedSqlChangeLogParser(INVALID_CHANGELOG_INVALID_PRECONDITION).parse("asdf.sql", new ChangeLogParameters(), new JUnitResourceAccessor()); }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void parse() throws Exception { ChangeLogParameters params = new ChangeLogParameters(); params.set("tablename", "table4"); DatabaseChangeLog changeLog = new MockFormattedSqlChangeLogParser(VALID_CHANGELOG).parse("asdf.sql", params, new JUnitResourceAccessor()); assertEquals("asdf.sql", changeLog.getLogicalFilePath()); assertEquals(8, changeLog.getChangeSets().size()); assertEquals("nvoxland", changeLog.getChangeSets().get(0).getAuthor()); assertEquals("1", changeLog.getChangeSets().get(0).getId()); assertEquals(1, changeLog.getChangeSets().get(0).getChanges().size()); assertEquals("select * from table1;", ((RawSQLChange) changeLog.getChangeSets().get(0).getChanges().get(0)).getSql()); assertNull(((RawSQLChange) changeLog.getChangeSets().get(0).getChanges().get(0)).getEndDelimiter()); assertTrue(((RawSQLChange) changeLog.getChangeSets().get(0).getChanges().get(0)).isSplittingStatements()); assertTrue(((RawSQLChange) changeLog.getChangeSets().get(0).getChanges().get(0)).isStrippingComments()); assertFalse(changeLog.getChangeSets().get(0).isAlwaysRun()); assertFalse(changeLog.getChangeSets().get(0).isRunOnChange()); assertTrue(changeLog.getChangeSets().get(0).isRunInTransaction()); assertNull(changeLog.getChangeSets().get(0).getContexts()); assertNull(changeLog.getChangeSets().get(0).getDbmsSet()); assertEquals("nvoxland", changeLog.getChangeSets().get(1).getAuthor()); assertEquals("2", changeLog.getChangeSets().get(1).getId()); assertEquals(1, changeLog.getChangeSets().get(1).getChanges().size()); assertEquals("create table table1 (\n" + " id int primary key\n" + ");", ((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).getSql()); assertEquals("X", ((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).getEndDelimiter()); assertFalse(((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).isSplittingStatements()); assertFalse(((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).isStrippingComments()); assertEquals("X", ((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).getEndDelimiter()); assertFalse(((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).isSplittingStatements()); assertFalse(((RawSQLChange) changeLog.getChangeSets().get(1).getChanges().get(0)).isStrippingComments()); assertTrue(changeLog.getChangeSets().get(1).isAlwaysRun()); assertTrue(changeLog.getChangeSets().get(1).isRunOnChange()); assertFalse(changeLog.getChangeSets().get(1).isRunInTransaction()); assertEquals("y", StringUtils.join(changeLog.getChangeSets().get(1).getContexts(), ",")); assertEquals("mysql", StringUtils.join(changeLog.getChangeSets().get(1).getDbmsSet(), ",")); assertEquals(1, changeLog.getChangeSets().get(1).getRollBackChanges().length); assertEquals("delete from table1;\n" + "drop table table1;", ((RawSQLChange) changeLog.getChangeSets().get(1).getRollBackChanges()[0]).getSql()); assertEquals("nvoxland", changeLog.getChangeSets().get(2).getAuthor()); assertEquals("3", changeLog.getChangeSets().get(2).getId()); assertEquals(1, changeLog.getChangeSets().get(2).getChanges().size()); assertEquals("create table table2 (\n" + " id int primary key\n" + ");\n" + "create table table3 (\n" + " id int primary key\n" + ");", ((RawSQLChange) changeLog.getChangeSets().get(2).getChanges().get(0)).getSql()); assertNull(((RawSQLChange) changeLog.getChangeSets().get(2).getChanges().get(0)).getEndDelimiter()); assertTrue(((RawSQLChange) changeLog.getChangeSets().get(2).getChanges().get(0)).isSplittingStatements()); assertTrue(((RawSQLChange) changeLog.getChangeSets().get(2).getChanges().get(0)).isStrippingComments()); assertEquals(1, changeLog.getChangeSets().get(2).getRollBackChanges().length); assertTrue(changeLog.getChangeSets().get(2).getRollBackChanges()[0] instanceof RawSQLChange); assertEquals("drop table table2;", ((RawSQLChange) changeLog.getChangeSets().get(2).getRollBackChanges()[0]).getSql()); assertEquals("alwyn", changeLog.getChangeSets().get(3).getAuthor()); assertEquals("4", changeLog.getChangeSets().get(3).getId()); assertEquals(1, changeLog.getChangeSets().get(3).getRollBackChanges().length); assertTrue(changeLog.getChangeSets().get(3).getRollBackChanges()[0] instanceof EmptyChange); assertEquals("nvoxland", changeLog.getChangeSets().get(4).getAuthor()); assertEquals("5", changeLog.getChangeSets().get(4).getId()); assertEquals(1, changeLog.getChangeSets().get(4).getRollBackChanges().length); assertTrue(changeLog.getChangeSets().get(4).getRollBackChanges()[0] instanceof EmptyChange); assertEquals("paikens", changeLog.getChangeSets().get(5).getAuthor()); assertEquals("6", changeLog.getChangeSets().get(5).getId()); assertEquals(1, changeLog.getChangeSets().get(5).getChanges().size()); assertTrue(changeLog.getChangeSets().get(5).getChanges().get(0) instanceof RawSQLChange); assertEquals("create table table4 (\n" + " id int primary key\n" + ");", ((RawSQLChange) changeLog.getChangeSets().get(5).getChanges().get(0)).getSql()); assertEquals(1, changeLog.getChangeSets().get(5).getRollBackChanges().length); assertTrue(changeLog.getChangeSets().get(5).getRollBackChanges()[0] instanceof RawSQLChange); assertEquals("drop table table4;", ((RawSQLChange) changeLog.getChangeSets().get(5).getRollBackChanges()[0]).getSql()); assertEquals("mysql", changeLog.getChangeSets().get(6).getAuthor()); assertEquals("1", changeLog.getChangeSets().get(6).getId()); assertEquals(1, changeLog.getChangeSets().get(6).getChanges().size()); assertTrue(changeLog.getChangeSets().get(6).getChanges().get(0) instanceof RawSQLChange); assertEquals("create table mysql_boo (\n" + " id int primary key\n" + ");", ((RawSQLChange) changeLog.getChangeSets().get(6).getChanges().get(0)).getSql()); assertEquals(1, changeLog.getChangeSets().get(6).getRollBackChanges().length); assertTrue(changeLog.getChangeSets().get(6).getRollBackChanges()[0] instanceof RawSQLChange); assertEquals("drop table mysql_boo;", ((RawSQLChange) changeLog.getChangeSets().get(6).getRollBackChanges()[0]).getSql()); ChangeSet cs = changeLog.getChangeSets().get(7); assertEquals("bboisvert", cs.getAuthor()); assertEquals("with_preconditions", cs.getId()); PreconditionContainer pc = cs.getPreconditions(); assertNotNull(pc); assertEquals(PreconditionContainer.FailOption.MARK_RAN, pc.getOnFail()); assertEquals(PreconditionContainer.ErrorOption.HALT, pc.getOnError()); assertEquals(PreconditionContainer.OnSqlOutputOption.FAIL, pc.getOnSqlOutput()); assertEquals(2, pc.getNestedPreconditions().size()); assertTrue(pc.getNestedPreconditions().get(0) instanceof SqlPrecondition); SqlPrecondition p0 = (SqlPrecondition) pc.getNestedPreconditions().get(0); assertEquals("0 table(s)", p0.getExpectedResult()); assertEquals("select count(*) || ' table(s)' from information_schema.tables where table_name = 'my_table'", p0.getSql()); assertTrue(pc.getNestedPreconditions().get(1) instanceof SqlPrecondition); SqlPrecondition p1 = (SqlPrecondition) pc.getNestedPreconditions().get(1); assertEquals("0", p1.getExpectedResult()); assertEquals("select count(*) from information_schema.columns where table_name = 'my_table' and column_name = 'id'", p1.getSql()); assertEquals(1, cs.getChanges().size()); assertTrue(cs.getChanges().get(0) instanceof RawSQLChange); assertEquals("create table my_table (\n" + " id int primary key\n" + ");", ((RawSQLChange) cs.getChanges().get(0)).getSql()); assertEquals(1, cs.getRollBackChanges().length); assertTrue(cs.getRollBackChanges()[0] instanceof RawSQLChange); assertEquals("drop table my_table;", ((RawSQLChange) cs.getRollBackChanges()[0]).getSql()); }

public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

FormattedSqlChangeLogParser implements ChangeLogParser { public DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException { DatabaseChangeLog changeLog = new DatabaseChangeLog(); changeLog.setPhysicalFilePath(physicalChangeLogLocation); BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(openChangeLogFile(physicalChangeLogLocation, resourceAccessor))); StringBuffer currentSql = new StringBuffer(); StringBuffer currentRollbackSql = new StringBuffer(); ChangeSet changeSet = null; RawSQLChange change = null; Pattern changeSetPattern = Pattern.compile("\\-\\-[\\s]*changeset (\\S+):(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern rollbackPattern = Pattern.compile("\\s*\\-\\-[\\s]*rollback (.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionsPattern = Pattern.compile("\\s*\\-\\-[\\s]*preconditions(.*)", Pattern.CASE_INSENSITIVE); Pattern preconditionPattern = Pattern.compile("\\s*\\-\\-[\\s]*precondition\\-([a-zA-Z0-9-]+) (.*)", Pattern.CASE_INSENSITIVE); Pattern stripCommentsPattern = Pattern.compile(".*stripComments:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern splitStatementsPattern = Pattern.compile(".*splitStatements:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern endDelimiterPattern = Pattern.compile(".*endDelimiter:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runOnChangePattern = Pattern.compile(".*runOnChange:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern runAlwaysPattern = Pattern.compile(".*runAlways:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern contextPattern = Pattern.compile(".*context:(\\S+).*", Pattern.CASE_INSENSITIVE); Pattern runInTransactionPattern = Pattern.compile(".*runInTransaction:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern dbmsPattern = Pattern.compile(".*dbms:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern failOnErrorPattern = Pattern.compile(".*failOnError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onFailPattern = Pattern.compile(".*onFail:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onErrorPattern = Pattern.compile(".*onError:(\\w+).*", Pattern.CASE_INSENSITIVE); Pattern onUpdateSqlPattern = Pattern.compile(".*onUpdateSQL:(\\w+).*", Pattern.CASE_INSENSITIVE); String line; while ((line = reader.readLine()) != null) { Matcher changeSetPatternMatcher = changeSetPattern.matcher(line); if (changeSetPatternMatcher.matches()) { String finalCurrentSql = changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString())); if (changeSet != null) { if (finalCurrentSql == null) { throw new ChangeLogParseException("No SQL for changeset " + changeSet.toString(false)); } change.setSql(finalCurrentSql); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } Matcher stripCommentsPatternMatcher = stripCommentsPattern.matcher(line); Matcher splitStatementsPatternMatcher = splitStatementsPattern.matcher(line); Matcher endDelimiterPatternMatcher = endDelimiterPattern.matcher(line); Matcher runOnChangePatternMatcher = runOnChangePattern.matcher(line); Matcher runAlwaysPatternMatcher = runAlwaysPattern.matcher(line); Matcher contextPatternMatcher = contextPattern.matcher(line); Matcher runInTransactionPatternMatcher = runInTransactionPattern.matcher(line); Matcher dbmsPatternMatcher = dbmsPattern.matcher(line); Matcher failOnErrorPatternMatcher = failOnErrorPattern.matcher(line); boolean stripComments = parseBoolean(stripCommentsPatternMatcher, changeSet, true); boolean splitStatements = parseBoolean(splitStatementsPatternMatcher, changeSet, true); boolean runOnChange = parseBoolean(runOnChangePatternMatcher, changeSet, false); boolean runAlways = parseBoolean(runAlwaysPatternMatcher, changeSet, false); boolean runInTransaction = parseBoolean(runInTransactionPatternMatcher, changeSet, true); boolean failOnError = parseBoolean(failOnErrorPatternMatcher, changeSet, true); String endDelimiter = parseString(endDelimiterPatternMatcher); String context = parseString(contextPatternMatcher); String dbms = parseString(dbmsPatternMatcher); changeSet = new ChangeSet(changeSetPatternMatcher.group(2), changeSetPatternMatcher.group(1), runAlways, runOnChange, physicalChangeLogLocation, context, dbms, runInTransaction); changeSet.setFailOnError(failOnError); changeLog.addChangeSet(changeSet); change = new RawSQLChange(); change.setSql(finalCurrentSql); change.setResourceAccessor(resourceAccessor); change.setSplitStatements(splitStatements); change.setStripComments(stripComments); change.setEndDelimiter(endDelimiter); changeSet.addChange(change); currentSql = new StringBuffer(); currentRollbackSql = new StringBuffer(); } else { if (changeSet != null) { Matcher rollbackMatcher = rollbackPattern.matcher(line); Matcher preconditionsMatcher = preconditionsPattern.matcher(line); Matcher preconditionMatcher = preconditionPattern.matcher(line); if (rollbackMatcher.matches()) { if (rollbackMatcher.groupCount() == 1) { currentRollbackSql.append(rollbackMatcher.group(1)).append("\n"); } } else if (preconditionsMatcher.matches()) { if (preconditionsMatcher.groupCount() == 1) { String body = preconditionsMatcher.group(1); Matcher onFailMatcher = onFailPattern.matcher(body); Matcher onErrorMatcher = onErrorPattern.matcher(body); Matcher onUpdateSqlMatcher = onUpdateSqlPattern.matcher(body); PreconditionContainer pc = new PreconditionContainer(); pc.setOnFail(StringUtils.trimToNull(parseString(onFailMatcher))); pc.setOnError(StringUtils.trimToNull(parseString(onErrorMatcher))); pc.setOnSqlOutput(StringUtils.trimToNull(parseString(onUpdateSqlMatcher))); changeSet.setPreconditions(pc); } } else if (preconditionMatcher.matches()) { if (changeSet.getPreconditions() == null) { changeSet.setPreconditions(new PreconditionContainer()); } if (preconditionMatcher.groupCount() == 2) { String name = StringUtils.trimToNull(preconditionMatcher.group(1)); if (name != null) { String body = preconditionMatcher.group(2).trim(); if ("sql-check".equals(name)) { changeSet.getPreconditions().addNestedPrecondition(parseSqlCheckCondition(body)); } else { throw new ChangeLogParseException("The '" + name + "' precondition type is not supported."); } } } } else { currentSql.append(line).append("\n"); } } } } if (changeSet != null) { change.setSql(changeLogParameters.expandExpressions(StringUtils.trimToNull(currentSql.toString()))); if (StringUtils.trimToNull(currentRollbackSql.toString()) != null) { try { if (currentRollbackSql.toString().trim().toLowerCase().matches("^not required.*")) { changeSet.addRollbackChange(new EmptyChange()); } else { RawSQLChange rollbackChange = new RawSQLChange(); rollbackChange.setSql(changeLogParameters.expandExpressions(currentRollbackSql.toString())); changeSet.addRollbackChange(rollbackChange); } } catch (UnsupportedChangeException e) { throw new RuntimeException(e); } } } } catch (IOException e) { throw new ChangeLogParseException(e); } finally { if (reader != null) { try { reader.close(); } catch (IOException ignore) { } } } return changeLog; } boolean supports(String changeLogFile, ResourceAccessor resourceAccessor); int getPriority(); DatabaseChangeLog parse(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor); }

@Test public void getInstance() { assertNotNull(ChangeLogParserFactory.getInstance()); assertTrue(ChangeLogParserFactory.getInstance() == ChangeLogParserFactory.getInstance()); }

public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; }

ChangeLogParserFactory { public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; } }

ChangeLogParserFactory { public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; } private ChangeLogParserFactory(); }

ChangeLogParserFactory { public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

ChangeLogParserFactory { public static ChangeLogParserFactory getInstance() { if (instance == null) { instance = new ChangeLogParserFactory(); } return instance; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

@Test public void register() { ChangeLogParserFactory.getInstance().getParsers().clear(); assertEquals(0, ChangeLogParserFactory.getInstance().getParsers().size()); ChangeLogParserFactory.getInstance().register(new MockChangeLogParser("mock")); assertEquals(1, ChangeLogParserFactory.getInstance().getParsers().size()); }

public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); }

ChangeLogParserFactory { public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); } }

ChangeLogParserFactory { public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); } private ChangeLogParserFactory(); }

ChangeLogParserFactory { public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

ChangeLogParserFactory { public void register(ChangeLogParser changeLogParser) { parsers.add(changeLogParser); Collections.sort(parsers, changelogParserComparator); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

@Test public void supportsSequences() { assertFalse(database.supportsSequences()); }

@Override public boolean supportsSequences() { return false; }

CacheDatabase extends AbstractDatabase { @Override public boolean supportsSequences() { return false; } }

CacheDatabase extends AbstractDatabase { @Override public boolean supportsSequences() { return false; } }

CacheDatabase extends AbstractDatabase { @Override public boolean supportsSequences() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { @Override public boolean supportsSequences() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void reset() { ChangeLogParserFactory instance1 = ChangeLogParserFactory.getInstance(); ChangeLogParserFactory.reset(); assertFalse(instance1 == ChangeLogParserFactory.getInstance()); }

public static void reset() { instance = new ChangeLogParserFactory(); }

ChangeLogParserFactory { public static void reset() { instance = new ChangeLogParserFactory(); } }

ChangeLogParserFactory { public static void reset() { instance = new ChangeLogParserFactory(); } private ChangeLogParserFactory(); }

ChangeLogParserFactory { public static void reset() { instance = new ChangeLogParserFactory(); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

ChangeLogParserFactory { public static void reset() { instance = new ChangeLogParserFactory(); } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

@Test public void getParsers() throws Exception { ChangeLogParser parser = ChangeLogParserFactory.getInstance().getParser("asdf.xml", new JUnitResourceAccessor()); assertNotNull(parser); assertTrue(parser instanceof XMLChangeLogSAXParser); }

public List<ChangeLogParser> getParsers() { return parsers; }

ChangeLogParserFactory { public List<ChangeLogParser> getParsers() { return parsers; } }

ChangeLogParserFactory { public List<ChangeLogParser> getParsers() { return parsers; } private ChangeLogParserFactory(); }

ChangeLogParserFactory { public List<ChangeLogParser> getParsers() { return parsers; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

ChangeLogParserFactory { public List<ChangeLogParser> getParsers() { return parsers; } private ChangeLogParserFactory(); static void reset(); static ChangeLogParserFactory getInstance(); List<ChangeLogParser> getParsers(); ChangeLogParser getParser(String fileNameOrExtension, ResourceAccessor resourceAccessor); void register(ChangeLogParser changeLogParser); void unregister(ChangeLogParser changeLogParser); }

@Test public void reset() { ServiceLocator instance1 = ServiceLocator.getInstance(); ServiceLocator.reset(); assertFalse(instance1 == ServiceLocator.getInstance()); }

public static void reset() { instance = new ServiceLocator(); }

ServiceLocator { public static void reset() { instance = new ServiceLocator(); } }

ServiceLocator { public static void reset() { instance = new ServiceLocator(); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); }

ServiceLocator { public static void reset() { instance = new ServiceLocator(); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

ServiceLocator { public static void reset() { instance = new ServiceLocator(); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

@Test public void getClasses() throws Exception { Class[] classes = serviceLocator.findClasses(ChangeLogParser.class); assertTrue(classes.length > 0); }

public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); }

ServiceLocator { public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); } }

ServiceLocator { public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); }

ServiceLocator { public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

ServiceLocator { public Class[] findClasses(Class requiredInterface) throws ServiceNotFoundException { logger.debug("ServiceLocator.findClasses for "+requiredInterface.getName()); try { Class.forName(requiredInterface.getName()); if (!classesBySuperclass.containsKey(requiredInterface)) { classesBySuperclass.put(requiredInterface, findClassesImpl(requiredInterface)); } } catch (Exception e) { throw new ServiceNotFoundException(e); } List<Class> classes = classesBySuperclass.get(requiredInterface); HashSet<Class> uniqueClasses = new HashSet<Class>(classes); return uniqueClasses.toArray(new Class[uniqueClasses.size()]); } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

@Test public void findClass() throws Exception { Class[] classes = serviceLocator.findClasses(Database.class); for (Class clazz : classes) { assertFalse(clazz.getName()+" is abstract", Modifier.isAbstract(clazz.getModifiers())); assertFalse(clazz.getName()+" is an interface", Modifier.isInterface(clazz.getModifiers())); assertNotNull(clazz.getConstructors()); } assertTrue(classes.length > 0); }

public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } }

ServiceLocator { public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } } }

ServiceLocator { public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); }

ServiceLocator { public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

ServiceLocator { public Class findClass(Class requiredInterface) throws ServiceNotFoundException { if (requiredInterface == Logger.class ) { return DefaultLogger.class; } else if ( requiredInterface == Executor.class ) { return JdbcExecutor.class; } else { throw new ServiceNotFoundException("Could not find implementation of " + requiredInterface.getName()); } } protected ServiceLocator(); protected ServiceLocator(ResourceAccessor accessor); protected ServiceLocator(PackageScanClassResolver classResolver); protected ServiceLocator(PackageScanClassResolver classResolver, ResourceAccessor accessor); static ServiceLocator getInstance(); static void setInstance(ServiceLocator newInstance); void setResourceAccessor(ResourceAccessor resourceAccessor); void addPackageToScan(String packageName); Class findClass(Class requiredInterface); Class[] findClasses(Class requiredInterface); Object newInstance(Class requiredInterface); static void reset(); }

@Test public void getInstance() { final Database oracle1 = new OracleDatabase() { @Override public boolean equals(Object o) { return o == this; } }; final Database oracle2 = new OracleDatabase() { @Override public boolean equals(Object o) { return o == this; } }; final Database mysql = new MySQLDatabase() { @Override public boolean equals(Object o) { return o == this; } }; assertNotNull(LockService.getInstance(oracle1)); assertNotNull(LockService.getInstance(oracle2)); assertNotNull(LockService.getInstance(mysql)); assertTrue(LockService.getInstance(oracle1) == LockService.getInstance(oracle1)); assertTrue(LockService.getInstance(oracle2) == LockService.getInstance(oracle2)); assertTrue(LockService.getInstance(mysql) == LockService.getInstance(mysql)); assertTrue(LockService.getInstance(oracle1) != LockService.getInstance(oracle2)); assertTrue(LockService.getInstance(oracle1) != LockService.getInstance(mysql)); }

public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); }

LockService { public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); } }

LockService { public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); } private LockService(Database database); }

LockService { public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); } private LockService(Database database); static LockService getInstance(Database database); void setChangeLogLockWaitTime(long changeLogLockWaitTime); void setChangeLogLockRecheckTime(long changeLogLocRecheckTime); boolean hasChangeLogLock(); void waitForLock(); boolean acquireLock(); void releaseLock(); DatabaseChangeLogLock[] listLocks(); void forceReleaseLock(); void reset(); static void resetAll(); }

LockService { public static LockService getInstance(Database database) { if (!instances.containsKey(database)) { instances.put(database, new LockService(database)); } return instances.get(database); } private LockService(Database database); static LockService getInstance(Database database); void setChangeLogLockWaitTime(long changeLogLockWaitTime); void setChangeLogLockRecheckTime(long changeLogLocRecheckTime); boolean hasChangeLogLock(); void waitForLock(); boolean acquireLock(); void releaseLock(); DatabaseChangeLogLock[] listLocks(); void forceReleaseLock(); void reset(); static void resetAll(); }

@Test public void getLineComment() { Assert.assertEquals("--", database.getLineComment()); }

@Override public String getLineComment() { return "--"; }

CacheDatabase extends AbstractDatabase { @Override public String getLineComment() { return "--"; } }

CacheDatabase extends AbstractDatabase { @Override public String getLineComment() { return "--"; } }

CacheDatabase extends AbstractDatabase { @Override public String getLineComment() { return "--"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { @Override public String getLineComment() { return "--"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void getDefaultDriver() { Assert.assertEquals("com.intersys.jdbc.CacheDriver", database.getDefaultDriver("jdbc:Cache: }

public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; }

CacheDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; } }

CacheDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; } }

CacheDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:Cache")) { return "com.intersys.jdbc.CacheDriver"; } return null; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void getTypeName() { Assert.assertEquals("cache", database.getTypeName()); }

public String getTypeName() { return "cache"; }

CacheDatabase extends AbstractDatabase { public String getTypeName() { return "cache"; } }

CacheDatabase extends AbstractDatabase { public String getTypeName() { return "cache"; } }

CacheDatabase extends AbstractDatabase { public String getTypeName() { return "cache"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { public String getTypeName() { return "cache"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("SYSDATE", database.getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; }

CacheDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; } }

CacheDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; } }

CacheDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSDATE"; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(database.supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return false; }

CacheDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

CacheDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

CacheDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); }

CacheDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getCurrentDateTimeFunction(); String getDefaultDriver(String url); int getPriority(); String getTypeName(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsInitiallyDeferrableColumns(); @Override String getLineComment(); @Override boolean supportsSequences(); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertTrue(getDatabase().supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return true; }

PostgresDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } }

PostgresDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } PostgresDatabase(); }

PostgresDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); }

PostgresDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; }

PostgresDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } }

PostgresDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } PostgresDatabase(); }

PostgresDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); }

PostgresDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } PostgresDatabase(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override Set<String> getSystemTablesAndViews(); int getPriority(); boolean supportsInitiallyDeferrableColumns(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getDatabaseChangeLogTableName(); @Override String getDatabaseChangeLogLockTableName(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); boolean supportsTablespaces(); @Override String getAutoIncrementClause(); @Override boolean generateAutoIncrementStartWith(BigInteger startWith); @Override boolean generateAutoIncrementBy(BigInteger incrementBy); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String tableName); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertTrue(getDatabase().supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return true; }

OracleDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } }

OracleDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } OracleDatabase(); }

OracleDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); }

OracleDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return true; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); static final String PRODUCT_NAME; }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("SYSTIMESTAMP", getDatabase().getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; }

OracleDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; } }

OracleDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; } OracleDatabase(); }

OracleDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); }

OracleDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "SYSTIMESTAMP"; } OracleDatabase(); int getPriority(); @Override void setConnection(DatabaseConnection conn); String getTypeName(); @Override String generatePrimaryKeyName(String tableName); boolean supportsInitiallyDeferrableColumns(); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String escapeIndexName(String schemaName, String indexName); @Override String getDateLiteral(String isoDate); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean shouldQuoteValue(String value); boolean supportsTablespaces(); @Override boolean supportsAutoIncrement(); @Override boolean supportsRestrictForeignKeys(); static final String PRODUCT_NAME; }

@Test public void multipleComments() { String raw = "\n" + "create table sqlfilerollback (id int);\n" + "\n" + "\n" + "create table sqlfilerollback2 (id int);"; String[] strings = StringUtils.processMutliLineSQL(raw, true, true, null); assertEquals(2, strings.length); assertEquals("create table sqlfilerollback (id int)", strings[0]); assertEquals("create table sqlfilerollback2 (id int)", strings[1]); }

public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter) { String stripped = stripComments ? stripComments(multiLineSQL) : multiLineSQL; if (splitStatements) { return splitSQL(stripped, endDelimiter); } else { return new String[]{stripped}; } } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void testIsSybaseProductName() { SybaseDatabase database = new SybaseDatabase(); assertTrue("Sybase SQL Server is a valid product name", database.isSybaseProductName("Sybase SQL Server")); assertTrue("sql server is a valid product name", database.isSybaseProductName("sql server")); assertTrue("ASE is a valid product name", database.isSybaseProductName("ASE")); assertTrue("Adaptive Server Enterprise is a valid product name", database.isSybaseProductName("Adaptive Server Enterprise")); }

boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); }

SybaseDatabase extends AbstractDatabase { boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); } }

SybaseDatabase extends AbstractDatabase { boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { boolean isSybaseProductName(String dbProductName) { return "Adaptive Server Enterprise".equals(dbProductName) || "Sybase SQL Server".equals(dbProductName) || "sql server".equals(dbProductName) || "ASE".equals(dbProductName); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetViewDefinitionWhenNoRows() throws Exception { SybaseDatabase database = new SybaseDatabase(); configureExecutor(database); assertEquals("", database.getViewDefinition("dbo", "view_name")); }

@Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetViewDefinitionWhenSingleRow() throws Exception { SybaseDatabase database = new SybaseDatabase(); configureExecutor(database, "foo"); assertEquals("foo", database.getViewDefinition("dbo", "view_name")); }

@Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetViewDefinitionWhenMultipleRows() throws Exception { SybaseDatabase database = new SybaseDatabase(); configureExecutor(database, "foo", " bar", " bat"); assertEquals("foo bar bat", database.getViewDefinition("dbo", "view_name")); }

@Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public String getViewDefinition(String schemaName, String viewName) throws DatabaseException { GetViewDefinitionStatement statement = new GetViewDefinitionStatement(convertRequestedSchemaToSchema(schemaName), viewName); Executor executor = ExecutorService.getInstance().getExecutor(this); @SuppressWarnings("unchecked") List<String> definitionRows = (List<String>) executor.queryForList(statement, String.class); StringBuilder definition = new StringBuilder(); for (String d : definitionRows) { definition.append(d); } return definition.toString(); } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetDatabaseMajorVersionWhenImplemented() throws Exception { DatabaseConnection connection = createNiceMock(DatabaseConnection.class); expect(connection.getDatabaseMajorVersion()).andReturn(15); replay(connection); SybaseDatabase database = new SybaseDatabase(); database.setConnection(connection); assertEquals(15, database.getDatabaseMajorVersion()); }

@Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetDatabaseMinorVersionWhenImplemented() throws Exception { DatabaseConnection connection = createNiceMock(DatabaseConnection.class); expect(connection.getDatabaseMinorVersion()).andReturn(5); replay(connection); SybaseDatabase database = new SybaseDatabase(); database.setConnection(connection); assertEquals(5, database.getDatabaseMinorVersion()); }

@Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetDatabaseMajorVersionWhenNotImplemented() throws Exception { DatabaseConnection connection = createNiceMock(DatabaseConnection.class); expect(connection.getDatabaseMajorVersion()).andThrow(new UnsupportedOperationException()); replay(connection); SybaseDatabase database = new SybaseDatabase(); database.setConnection(connection); assertEquals(-1, database.getDatabaseMajorVersion()); }

@Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMajorVersion() throws DatabaseException { try { return getConnection().getDatabaseMajorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Test public void testGetDatabaseMinorVersionWhenNotImplemented() throws Exception { DatabaseConnection connection = createNiceMock(DatabaseConnection.class); expect(connection.getDatabaseMinorVersion()).andThrow(new UnsupportedOperationException()); replay(connection); SybaseDatabase database = new SybaseDatabase(); database.setConnection(connection); assertEquals(-1, database.getDatabaseMinorVersion()); }

@Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); }

SybaseDatabase extends AbstractDatabase { @Override public int getDatabaseMinorVersion() throws DatabaseException { try { return getConnection().getDatabaseMinorVersion(); } catch (UnsupportedOperationException e) { LogFactory.getLogger() .warning("Your JDBC driver does not support getDatabaseMajorVersion(). Consider upgrading it."); return -1; } } SybaseDatabase(); String getProductName(); String getTypeName(); int getPriority(); @Override boolean supportsDDLInTransaction(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override boolean supportsRestrictForeignKeys(); @Override String escapeDatabaseObject(String objectName); @Override String getViewDefinition(String schemaName, String viewName); @Override int getDatabaseMajorVersion(); @Override int getDatabaseMinorVersion(); @Override String escapeIndexName(String schemaName, String indexName); static final String PRODUCT_NAME; }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return false; }

H2Database extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

H2Database extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } H2Database(); }

H2Database extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

H2Database extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; }

H2Database extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } }

H2Database extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } H2Database(); }

H2Database extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

H2Database extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

@Test public void noComments() { String noComments=" Some text but no comments"; String result = StringUtils.stripComments(noComments); assertEquals(noComments.trim(),result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void testGetDefaultDriver() { Database database = getDatabase(); assertEquals("org.h2.Driver", database.getDefaultDriver("jdbc:h2:mem:liquibase")); assertNull(database.getDefaultDriver("jdbc:db2: }

public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; }

H2Database extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; } }

H2Database extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; } H2Database(); }

H2Database extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

H2Database extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:h2")) { return "org.h2.Driver"; } return null; } H2Database(); String getTypeName(); String getDefaultDriver(String url); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); boolean supportsTablespaces(); @Override String getViewDefinition(String schemaName, String name); @Override Date parseDate(String dateAsString); @Override boolean isLocalDatabase(); @Override boolean supportsSequences(); @Override String getConcatSql(String... values); @Override String getDateLiteral(String isoDate); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override boolean isReservedWord(String objectName); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return false; }

MySQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

MySQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

MySQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); }

MySQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); static final String PRODUCT_NAME; }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("NOW()", getDatabase().getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; }

MySQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } }

MySQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } }

MySQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); }

MySQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "NOW()"; } String getTypeName(); int getPriority(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); @Override boolean supportsSequences(); boolean supportsInitiallyDeferrableColumns(); String getCurrentDateTimeFunction(); @Override String getLineComment(); @Override String getConcatSql(String ... values); boolean supportsTablespaces(); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String escapeDatabaseObject(String objectName); @Override String escapeIndexName(String schemaName, String indexName); @Override boolean supportsForeignKeyDisable(); @Override boolean disableForeignKeyChecks(); @Override void enableForeignKeyChecks(); static final String PRODUCT_NAME; }

@Override @Test public void supportsInitiallyDeferrableColumns() { assertFalse(getDatabase().supportsInitiallyDeferrableColumns()); }

public boolean supportsInitiallyDeferrableColumns() { return false; }

MSSQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } }

MSSQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } MSSQLDatabase(); }

MSSQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); }

MSSQLDatabase extends AbstractDatabase { public boolean supportsInitiallyDeferrableColumns() { return false; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Override @Test public void getCurrentDateTimeFunction() { Assert.assertEquals("GETDATE()", getDatabase().getCurrentDateTimeFunction()); }

public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; }

MSSQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; } }

MSSQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; } MSSQLDatabase(); }

MSSQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); }

MSSQLDatabase extends AbstractDatabase { public String getCurrentDateTimeFunction() { if (currentDateTimeFunction != null) { return currentDateTimeFunction; } return "GETDATE()"; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void getDefaultDriver() { Database database = new MSSQLDatabase(); assertEquals("com.microsoft.sqlserver.jdbc.SQLServerDriver", database.getDefaultDriver("jdbc:sqlserver: assertNull(database.getDefaultDriver("jdbc:oracle:thin: }

public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; }

MSSQLDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; } }

MSSQLDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; } MSSQLDatabase(); }

MSSQLDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); }

MSSQLDatabase extends AbstractDatabase { public String getDefaultDriver(String url) { if (url.startsWith("jdbc:sqlserver")) { return "com.microsoft.sqlserver.jdbc.SQLServerDriver"; } else if (url.startsWith("jdbc:jtds:sqlserver")) { return "net.sourceforge.jtds.jdbc.Driver"; } return null; } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void changeDefaultSchema() throws DatabaseException { Database database = new MSSQLDatabase(); assertEquals("dbo", database.getDefaultSchemaName()); database.setDefaultSchemaName("myschema"); assertEquals("myschema", database.getDefaultSchemaName()); }

@Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } }

MSSQLDatabase extends AbstractDatabase { @Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } } }

MSSQLDatabase extends AbstractDatabase { @Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } } MSSQLDatabase(); }

MSSQLDatabase extends AbstractDatabase { @Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); }

MSSQLDatabase extends AbstractDatabase { @Override public String getDefaultSchemaName() { String defaultSchemaName = super.getDefaultSchemaName(); if (defaultSchemaName == null) { return "dbo"; } else { return defaultSchemaName; } } MSSQLDatabase(); String getTypeName(); int getPriority(); @Override Set<String> getSystemTablesAndViews(); boolean supportsInitiallyDeferrableColumns(); @Override boolean supportsSequences(); boolean isCorrectDatabaseImplementation(DatabaseConnection conn); String getDefaultDriver(String url); String getCurrentDateTimeFunction(); @Override String getDefaultCatalogName(); @Override String getConcatSql(String... values); @Override String escapeIndexName(String schemaName, String indexName); boolean supportsTablespaces(); @Override boolean isSystemTable(String catalogName, String schemaName, String tableName); @Override boolean isSystemView(String catalogName, String schemaName, String viewName); String generateDefaultConstraintName(String tableName, String columnName); @Override String escapeDatabaseObject(String objectName); @Override String convertRequestedSchemaToCatalog(String requestedSchema); @Override String convertRequestedSchemaToSchema(String requestedSchema); @Override String getDateLiteral(String isoDate); @Override boolean supportsRestrictForeignKeys(); @Override boolean supportsDropTableCascadeConstraints(); @Override String getDefaultSchemaName(); @Override String getViewDefinition(String schemaName, String viewName); static final String PRODUCT_NAME; }

@Test public void getInstance() { assertNotNull(DatabaseFactory.getInstance()); }

public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; }

DatabaseFactory { public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; } }

DatabaseFactory { public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; } protected DatabaseFactory(); }

DatabaseFactory { public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; } protected DatabaseFactory(); static DatabaseFactory getInstance(); static void reset(); List<Database> getImplementedDatabases(); void register(Database database); Database findCorrectDatabaseImplementation(DatabaseConnection connection); String findDefaultDriver(String url); void clearRegistry(); }

DatabaseFactory { public static DatabaseFactory getInstance() { if (instance == null) { instance = new DatabaseFactory(); } return instance; } protected DatabaseFactory(); static DatabaseFactory getInstance(); static void reset(); List<Database> getImplementedDatabases(); void register(Database database); Database findCorrectDatabaseImplementation(DatabaseConnection connection); String findDefaultDriver(String url); void clearRegistry(); }

@Test public void findTypeConverter() { assertTrue(TypeConverterFactory.getInstance().findTypeConverter(new UnsupportedDatabase()) instanceof DefaultTypeConverter); assertTrue(TypeConverterFactory.getInstance().findTypeConverter(new H2Database()) instanceof H2TypeConverter); }

public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); }

TypeConverterFactory { public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); } }

TypeConverterFactory { public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); } private TypeConverterFactory(); }

TypeConverterFactory { public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); } private TypeConverterFactory(); static TypeConverterFactory getInstance(); TypeConverter findTypeConverter(Database database); void register(TypeConverter typeConverter); void register(Class<? extends TypeConverter> typeConverterClass); }

TypeConverterFactory { public TypeConverter findTypeConverter(Database database) { SortedSet<TypeConverter> converters = new TreeSet<TypeConverter>(new Comparator<TypeConverter>() { public int compare(TypeConverter o1, TypeConverter o2) { return Integer.valueOf(o1.getPriority()).compareTo(o2.getPriority()); } }); for (TypeConverter converter : allConverters) { if (converter.supports(database)) { converters.add(converter); } } return converters.last(); } private TypeConverterFactory(); static TypeConverterFactory getInstance(); TypeConverter findTypeConverter(Database database); void register(TypeConverter typeConverter); void register(Class<? extends TypeConverter> typeConverterClass); }

@Test public void getBooleanType() { assertEquals("NUMBER(1)", new OracleTypeConverter().getBooleanType().toString()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); }

OracleTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

OracleTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("NUMBER(1)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

@Test public void singleLineNoNewLine() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql,result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void getCurrencyType() { assertEquals("NUMBER(15, 2)", new OracleTypeConverter().getCurrencyType().toString()); }

@Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); }

OracleTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

OracleTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("NUMBER(15, 2)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

@Test public void getUUIDType() { assertEquals("RAW(16)", new OracleTypeConverter().getUUIDType().toString()); }

@Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); }

OracleTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

OracleTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("RAW(16)"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

@Test public void getDateTimeType() { assertEquals("TIMESTAMP", new OracleTypeConverter().getDateTimeType().toString()); }

@Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); }

OracleTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } }

OracleTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

OracleTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override String convertToDatabaseTypeString(Column referenceColumn, Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override TimeType getTimeType(); @Override DateTimeType getDateTimeType(); @Override BigIntType getBigIntType(); @Override IntType getIntType(); @Override VarcharType getVarcharType(); @Override NVarcharType getNVarcharType(); @Override DoubleType getDoubleType(); @Override TinyIntType getTinyIntType(); }

@Test public void getBlobType() { assertEquals("VARBINARY(MAX)", new MSSQLTypeConverter().getBlobType().toString()); }

@Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("VARBINARY(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getBooleanType() { assertEquals("BIT", new MSSQLTypeConverter().getBooleanType().toString()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("BIT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getCurrencyType() { assertEquals("MONEY", new MSSQLTypeConverter().getCurrencyType().toString()); }

@Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getUUIDType() { assertEquals("UNIQUEIDENTIFIER", new MSSQLTypeConverter().getUUIDType().toString()); }

@Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UNIQUEIDENTIFIER"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getClobType() { assertEquals("NVARCHAR(MAX)", new MSSQLTypeConverter().getClobType().toString()); }

@Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("NVARCHAR(MAX)"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getDateType() { assertEquals("SMALLDATETIME", new MSSQLTypeConverter().getDateType().toString()); }

@Override public DateType getDateType() { return new DateType("SMALLDATETIME"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public DateType getDateType() { return new DateType("SMALLDATETIME"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public DateType getDateType() { return new DateType("SMALLDATETIME"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public DateType getDateType() { return new DateType("SMALLDATETIME"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public DateType getDateType() { return new DateType("SMALLDATETIME"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void getNumberType() { assertEquals("NUMERIC", new MSSQLTypeConverter().getNumberType().toString()); }

@Override public NumberType getNumberType() { return new NumberType("NUMERIC"); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public NumberType getNumberType() { return new NumberType("NUMERIC"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public NumberType getNumberType() { return new NumberType("NUMERIC"); } }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public NumberType getNumberType() { return new NumberType("NUMERIC"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

MSSQLTypeConverter extends AbstractTypeConverter { @Override public NumberType getNumberType() { return new NumberType("NUMERIC"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override DateType getDateType(); @Override TimeType getTimeType(); @Override BooleanType getBooleanType(); @Override CurrencyType getCurrencyType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override NumberType getNumberType(); @Override DoubleType getDoubleType(); }

@Test public void singleLineNoFollowOnLine() { String sql = "Some text" ; String comment = " -- with comment\n"; String totalLine=sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql.trim(),result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void getBlobType() { assertEquals("BYTEA", new PostgresTypeConverter().getBlobType().toString()); }

@Override public BlobType getBlobType() { return new BlobType("BYTEA"); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("BYTEA"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("BYTEA"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("BYTEA"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("BYTEA"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getClobType() { assertEquals("TEXT", new PostgresTypeConverter().getClobType().toString()); }

@Override public ClobType getClobType() { return new ClobType("TEXT"); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("TEXT"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("TEXT"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("TEXT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("TEXT"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getDateTimeType() { assertEquals("TIMESTAMP WITH TIME ZONE", new PostgresTypeConverter().getDateTimeType().toString()); }

@Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP WITH TIME ZONE"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_BigSerial_AutoIncrement() { assertEquals("bigserial", new PostgresTypeConverter().getDataType("bigserial", true).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_BigInt_AutoIncrement() { assertEquals("bigserial", new PostgresTypeConverter().getDataType("bigint", true).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_TinyText() { assertEquals("TEXT", new PostgresTypeConverter().getDataType("TINYTEXT", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_Text() { assertEquals("TEXT", new PostgresTypeConverter().getDataType("TEXT", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_MediumText() { assertEquals("TEXT", new PostgresTypeConverter().getDataType("MEDIUMTEXT", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_LongText() { assertEquals("TEXT", new PostgresTypeConverter().getDataType("LONGTEXT", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_TinyBlob() { assertEquals("BYTEA", new PostgresTypeConverter().getDataType("TINYBLOB", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void singleLineMultipleComments() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment + "\n"+ sql + comment ; String result = StringUtils.stripComments(totalLine); assertEquals(sql+"\n"+sql,result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void getColumnType_Blob() { assertEquals("BYTEA", new PostgresTypeConverter().getDataType("BLOB", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_MediumBlob() { assertEquals("BYTEA", new PostgresTypeConverter().getDataType("MEDIUMBLOB", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getColumnType_LongBlob() { assertEquals("BYTEA", new PostgresTypeConverter().getDataType("LONGBLOB", false).toString()); }

@Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

PostgresTypeConverter extends AbstractTypeConverter { @Override public DataType getDataType(String columnTypeString, Boolean autoIncrement) { DataType type = super.getDataType(columnTypeString, autoIncrement); if (type.getDataTypeName().toLowerCase().contains("text")) { type = getClobType(); } else if (type.getDataTypeName().toLowerCase().contains("blob")) { type = getBlobType(); } else if (type.getDataTypeName().toLowerCase().startsWith("float8")) { type.setDataTypeName("FLOAT8"); } else if (type.getDataTypeName().toLowerCase().startsWith("float4")) { type.setDataTypeName("FLOAT4"); } if (autoIncrement != null && autoIncrement) { if ("integer".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("serial"); } else if ("bigint".equals(type.getDataTypeName().toLowerCase()) || "bigserial".equals(type.getDataTypeName().toLowerCase())) { type.setDataTypeName("bigserial"); } else { type.setDataTypeName("serial"); } } return type; } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DataType getDataType(String columnTypeString, Boolean autoIncrement); @Override ClobType getClobType(); @Override BlobType getBlobType(); @Override DateTimeType getDateTimeType(); @Override NumberType getNumberType(); @Override TinyIntType getTinyIntType(); @Override DoubleType getDoubleType(); }

@Test public void getBlobType() { assertEquals("LONGVARBINARY", new H2TypeConverter().getBlobType().toString()); }

@Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); }

H2TypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

H2TypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

@Test public void getUUIDType() { assertEquals("UUID", new H2TypeConverter().getUUIDType().toString()); }

@Override public UUIDType getUUIDType() { return new UUIDType("UUID"); }

H2TypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UUID"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UUID"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UUID"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

H2TypeConverter extends AbstractTypeConverter { @Override public UUIDType getUUIDType() { return new UUIDType("UUID"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

@Test public void getClobType() { assertEquals("LONGVARCHAR", new H2TypeConverter().getClobType().toString()); }

@Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); }

H2TypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

H2TypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

@Test public void getDateTimeType() { assertEquals("TIMESTAMP", new H2TypeConverter().getDateTimeType().toString()); }

@Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); }

H2TypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } }

H2TypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

H2TypeConverter extends AbstractTypeConverter { @Override public DateTimeType getDateTimeType() { return new DateTimeType("TIMESTAMP"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override DateTimeType getDateTimeType(); @Override UUIDType getUUIDType(); @Override ClobType getClobType(); @Override BlobType getBlobType(); }

@Test public void getFalseBooleanValue() { assertEquals("0", new CacheTypeConverter().getBooleanType().getFalseBooleanValue()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void getTrueBooleanValue() { assertEquals("1", new CacheTypeConverter().getBooleanType().getTrueBooleanValue()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void getBlobType() { assertEquals("LONGVARBINARY", new CacheTypeConverter().getBlobType().toString()); }

@Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BlobType getBlobType() { return new BlobType("LONGVARBINARY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void singleLineWithFollowupLine() { String sql = "Some text" ; String comment = " -- with comment"; String totalLine=sql + comment + "\n" + sql ; String result = StringUtils.stripComments(totalLine); assertEquals(sql + "\n" + sql,result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void getBooleanType() { assertEquals("INT", new CacheTypeConverter().getBooleanType().toString()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType(); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void getClobType() { assertEquals("LONGVARCHAR", new CacheTypeConverter().getClobType().toString()); }

@Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); }

CacheTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGVARCHAR"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void getCurrencyType() { assertEquals("MONEY", new CacheTypeConverter().getCurrencyType().toString()); }

@Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); }

CacheTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } }

CacheTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

CacheTypeConverter extends AbstractTypeConverter { @Override public CurrencyType getCurrencyType() { return new CurrencyType("MONEY"); } int getPriority(); boolean supports(Database database); @Override Object convertDatabaseValueToObject(Object defaultValue, int dataType, int columnSize, int decimalDigits, Database database); @Override BlobType getBlobType(); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override CurrencyType getCurrencyType(); }

@Test public void getBooleanType() { assertEquals("TINYINT(1)", new MySQLTypeConverter().getBooleanType().toString()); }

@Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); }

MySQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); } }

MySQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); } }

MySQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }

MySQLTypeConverter extends AbstractTypeConverter { @Override public BooleanType getBooleanType() { return new BooleanType.NumericBooleanType("TINYINT(1)"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }

@Test public void getClobType() { assertEquals("LONGTEXT", new MySQLTypeConverter().getClobType().toString()); }

@Override public ClobType getClobType() { return new ClobType("LONGTEXT"); }

MySQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGTEXT"); } }

MySQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGTEXT"); } }

MySQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGTEXT"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }

MySQLTypeConverter extends AbstractTypeConverter { @Override public ClobType getClobType() { return new ClobType("LONGTEXT"); } int getPriority(); boolean supports(Database database); @Override BooleanType getBooleanType(); @Override ClobType getClobType(); @Override BlobType getLongBlobType(); @Override NumberType getNumberType(); }

@Test public void getInstance() { assertNotNull(ChangeLogSerializerFactory.getInstance()); assertTrue(ChangeLogSerializerFactory.getInstance() == ChangeLogSerializerFactory.getInstance()); }

public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; }

ChangeLogSerializerFactory { public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; } }

ChangeLogSerializerFactory { public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; } private ChangeLogSerializerFactory(); }

ChangeLogSerializerFactory { public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

ChangeLogSerializerFactory { public static ChangeLogSerializerFactory getInstance() { if (instance == null) { instance = new ChangeLogSerializerFactory(); } return instance; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

@Test public void register() { ChangeLogSerializerFactory.getInstance().getSerializers().clear(); assertEquals(0, ChangeLogSerializerFactory.getInstance().getSerializers().size()); ChangeLogSerializerFactory.getInstance().register(new MockChangeLogSerializer("mock")); assertEquals(1, ChangeLogSerializerFactory.getInstance().getSerializers().size()); }

public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } }

ChangeLogSerializerFactory { public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } } }

ChangeLogSerializerFactory { public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } } private ChangeLogSerializerFactory(); }

ChangeLogSerializerFactory { public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

ChangeLogSerializerFactory { public void register(ChangeLogSerializer changeLogSerializer) { for (String extension : changeLogSerializer.getValidFileExtensions()) { serializers.put(extension, changeLogSerializer); } } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

@Test public void reset() { ChangeLogSerializerFactory instance1 = ChangeLogSerializerFactory.getInstance(); ChangeLogSerializerFactory.reset(); assertFalse(instance1 == ChangeLogSerializerFactory.getInstance()); }

public static void reset() { instance = new ChangeLogSerializerFactory(); }

ChangeLogSerializerFactory { public static void reset() { instance = new ChangeLogSerializerFactory(); } }

ChangeLogSerializerFactory { public static void reset() { instance = new ChangeLogSerializerFactory(); } private ChangeLogSerializerFactory(); }

ChangeLogSerializerFactory { public static void reset() { instance = new ChangeLogSerializerFactory(); } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

ChangeLogSerializerFactory { public static void reset() { instance = new ChangeLogSerializerFactory(); } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

@Test public void getSerializers() { ChangeLogSerializer serializer = ChangeLogSerializerFactory.getInstance().getSerializer("xml"); assertNotNull(serializer); assertTrue(serializer instanceof XMLChangeLogSerializer); }

public Map<String, ChangeLogSerializer> getSerializers() { return serializers; }

ChangeLogSerializerFactory { public Map<String, ChangeLogSerializer> getSerializers() { return serializers; } }

ChangeLogSerializerFactory { public Map<String, ChangeLogSerializer> getSerializers() { return serializers; } private ChangeLogSerializerFactory(); }

ChangeLogSerializerFactory { public Map<String, ChangeLogSerializer> getSerializers() { return serializers; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

ChangeLogSerializerFactory { public Map<String, ChangeLogSerializer> getSerializers() { return serializers; } private ChangeLogSerializerFactory(); static void reset(); static ChangeLogSerializerFactory getInstance(); Map<String, ChangeLogSerializer> getSerializers(); ChangeLogSerializer getSerializer(String fileNameOrExtension); void register(ChangeLogSerializer changeLogSerializer); void unregister(ChangeLogSerializer changeLogSerializer); }

@Test public void createNode_addAutoIncrementChange() throws Exception { AddAutoIncrementChange change = new AddAutoIncrementChange(); change.setSchemaName("SCHEMA_NAME"); change.setTableName("TABLE_NAME"); change.setColumnName("COLUMN_NAME"); change.setColumnDataType("DATATYPE(255)"); Element node = new XMLChangeLogSerializer(DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()).createNode(change); assertEquals("addAutoIncrement", node.getTagName()); NamedNodeMap attributes = node.getAttributes(); for (int i = 0; i < attributes.getLength(); i++) { Node attribute = attributes.item(i); if (attribute.getNodeName().equals("schemaName")) { assertEquals("SCHEMA_NAME", attribute.getNodeValue()); } else if (attribute.getNodeName().equals("tableName")) { assertEquals("TABLE_NAME", attribute.getNodeValue()); } else if (attribute.getNodeName().equals("columnName")) { assertEquals("COLUMN_NAME", attribute.getNodeValue()); } else if (attribute.getNodeName().equals("columnDataType")) { assertEquals("DATATYPE(255)", attribute.getNodeValue()); } else { fail("unexpected attribute " + attribute.getNodeName()); } } }

public Element createNode(SqlVisitor visitor) { Element node = currentChangeLogFileDOM.createElementNS(XMLChangeLogSAXParser.getDatabaseChangeLogNameSpace(), visitor.getName()); try { List<Field> allFields = new ArrayList<Field>(); Class classToExtractFieldsFrom = visitor.getClass(); while (!classToExtractFieldsFrom.equals(Object.class)) { allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields())); classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass(); } for (Field field : allFields) { field.setAccessible(true); ChangeProperty changePropertyAnnotation = field.getAnnotation(ChangeProperty.class); if (changePropertyAnnotation != null && !changePropertyAnnotation.includeInSerialization()) { continue; } if (field.getName().equals("serialVersionUID")) { continue; } if (field.getName().equals("$VRc")) { continue; } String propertyName = field.getName(); Object value = field.get(visitor); if (value != null) { node.setAttribute(propertyName, value.toString()); } } } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } return node; }

XMLChangeLogSerializer implements ChangeLogSerializer { public Element createNode(SqlVisitor visitor) { Element node = currentChangeLogFileDOM.createElementNS(XMLChangeLogSAXParser.getDatabaseChangeLogNameSpace(), visitor.getName()); try { List<Field> allFields = new ArrayList<Field>(); Class classToExtractFieldsFrom = visitor.getClass(); while (!classToExtractFieldsFrom.equals(Object.class)) { allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields())); classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass(); } for (Field field : allFields) { field.setAccessible(true); ChangeProperty changePropertyAnnotation = field.getAnnotation(ChangeProperty.class); if (changePropertyAnnotation != null && !changePropertyAnnotation.includeInSerialization()) { continue; } if (field.getName().equals("serialVersionUID")) { continue; } if (field.getName().equals("$VRc")) { continue; } String propertyName = field.getName(); Object value = field.get(visitor); if (value != null) { node.setAttribute(propertyName, value.toString()); } } } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } return node; } }

XMLChangeLogSerializer implements ChangeLogSerializer { public Element createNode(SqlVisitor visitor) { Element node = currentChangeLogFileDOM.createElementNS(XMLChangeLogSAXParser.getDatabaseChangeLogNameSpace(), visitor.getName()); try { List<Field> allFields = new ArrayList<Field>(); Class classToExtractFieldsFrom = visitor.getClass(); while (!classToExtractFieldsFrom.equals(Object.class)) { allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields())); classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass(); } for (Field field : allFields) { field.setAccessible(true); ChangeProperty changePropertyAnnotation = field.getAnnotation(ChangeProperty.class); if (changePropertyAnnotation != null && !changePropertyAnnotation.includeInSerialization()) { continue; } if (field.getName().equals("serialVersionUID")) { continue; } if (field.getName().equals("$VRc")) { continue; } String propertyName = field.getName(); Object value = field.get(visitor); if (value != null) { node.setAttribute(propertyName, value.toString()); } } } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } return node; } XMLChangeLogSerializer(); protected XMLChangeLogSerializer(Document currentChangeLogFileDOM); }

XMLChangeLogSerializer implements ChangeLogSerializer { public Element createNode(SqlVisitor visitor) { Element node = currentChangeLogFileDOM.createElementNS(XMLChangeLogSAXParser.getDatabaseChangeLogNameSpace(), visitor.getName()); try { List<Field> allFields = new ArrayList<Field>(); Class classToExtractFieldsFrom = visitor.getClass(); while (!classToExtractFieldsFrom.equals(Object.class)) { allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields())); classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass(); } for (Field field : allFields) { field.setAccessible(true); ChangeProperty changePropertyAnnotation = field.getAnnotation(ChangeProperty.class); if (changePropertyAnnotation != null && !changePropertyAnnotation.includeInSerialization()) { continue; } if (field.getName().equals("serialVersionUID")) { continue; } if (field.getName().equals("$VRc")) { continue; } String propertyName = field.getName(); Object value = field.get(visitor); if (value != null) { node.setAttribute(propertyName, value.toString()); } } } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } return node; } XMLChangeLogSerializer(); protected XMLChangeLogSerializer(Document currentChangeLogFileDOM); void setCurrentChangeLogFileDOM(Document currentChangeLogFileDOM); String[] getValidFileExtensions(); String serialize(DatabaseChangeLog databaseChangeLog); String serialize(Change change); String serialize(SqlVisitor visitor); String serialize(ColumnConfig columnConfig); String serialize(ChangeSet changeSet); void write(List<ChangeSet> changeSets, OutputStream out); Element createNode(SqlVisitor visitor); Element createNode(Change change); Element createNode(String nodeName, String nodeContent); Element createNode(ColumnConfig columnConfig); Element createNode(ChangeSet changeSet); Element createNode(CustomChangeWrapper change); }

XMLChangeLogSerializer implements ChangeLogSerializer { public Element createNode(SqlVisitor visitor) { Element node = currentChangeLogFileDOM.createElementNS(XMLChangeLogSAXParser.getDatabaseChangeLogNameSpace(), visitor.getName()); try { List<Field> allFields = new ArrayList<Field>(); Class classToExtractFieldsFrom = visitor.getClass(); while (!classToExtractFieldsFrom.equals(Object.class)) { allFields.addAll(Arrays.asList(classToExtractFieldsFrom.getDeclaredFields())); classToExtractFieldsFrom = classToExtractFieldsFrom.getSuperclass(); } for (Field field : allFields) { field.setAccessible(true); ChangeProperty changePropertyAnnotation = field.getAnnotation(ChangeProperty.class); if (changePropertyAnnotation != null && !changePropertyAnnotation.includeInSerialization()) { continue; } if (field.getName().equals("serialVersionUID")) { continue; } if (field.getName().equals("$VRc")) { continue; } String propertyName = field.getName(); Object value = field.get(visitor); if (value != null) { node.setAttribute(propertyName, value.toString()); } } } catch (Exception e) { throw new UnexpectedLiquibaseException(e); } return node; } XMLChangeLogSerializer(); protected XMLChangeLogSerializer(Document currentChangeLogFileDOM); void setCurrentChangeLogFileDOM(Document currentChangeLogFileDOM); String[] getValidFileExtensions(); String serialize(DatabaseChangeLog databaseChangeLog); String serialize(Change change); String serialize(SqlVisitor visitor); String serialize(ColumnConfig columnConfig); String serialize(ChangeSet changeSet); void write(List<ChangeSet> changeSets, OutputStream out); Element createNode(SqlVisitor visitor); Element createNode(Change change); Element createNode(String nodeName, String nodeContent); Element createNode(ColumnConfig columnConfig); Element createNode(ChangeSet changeSet); Element createNode(CustomChangeWrapper change); }

@Test public void multiLineOnOwnLine() { String sql = "" ; String result = StringUtils.stripComments(sql); assertEquals("",result); }

public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

StringUtils { public static String stripComments(String multiLineSQL) { String strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*\n").matcher(multiLineSQL).replaceAll("$1\n"); strippedSingleLines = Pattern.compile("(.*?)\\s*\\-\\-.*$").matcher(strippedSingleLines).replaceAll("$1\n"); return Pattern.compile("/\\*.*?\\*/", Pattern.DOTALL).matcher(strippedSingleLines).replaceAll("").trim(); } static String trimToEmpty(String string); static String trimToNull(String string); static String[] processMutliLineSQL(String multiLineSQL,boolean stripComments, boolean splitStatements, String endDelimiter); static String[] splitSQL(String multiLineSQL, String endDelimiter); static String stripComments(String multiLineSQL); static String join(String[] array, String delimiter); static String join(Collection<String> collection, String delimiter); static List<String> splitAndTrim(String s, String regex); static String repeat(String string, int times); static String join(Integer[] array, String delimiter); static String join(int[] array, String delimiter); }

@Test public void canDetermineHeight() { PrintPayload payload = new PrintPayload(); payload.append("Line1"); payload.append("Line2"); payload.append("Line3"); payload.append("Line4"); PrintPreview printPreview = new PrintPreview(payload, getPrinterSettings()); assertThat(printPreview.determineHeight()).isEqualTo(144); }

public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; }

PrintPreview { public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; } }

PrintPreview { public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); }

PrintPreview { public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }

PrintPreview { public int determineHeight() { int height = 0; for (PrintRow row : processRowsBeforePreviewing(printPayload.getRows())) { if (row instanceof TextRow) { PrinterFont font = getFont(((TextRow) row).getPrinterFontId()); height += font.getLineHeight(); } else if (row instanceof ImageRow) { height += ((ImageRow) row).getImage().getHeight() + VERTICAL_MARGIN * 2; } } return height + VERTICAL_MARGIN * 2; } PrintPreview(PrintPayload printPayload, PrinterSettings printerSettings); Bitmap getBitmap(); Bitmap getScaledBitmap(Context context); byte[] getCompressedBitmap(); int determineHeight(); }

@Test(expected = IllegalArgumentException.class) public void appendNullImageWillThrow() { PrintPayload payload = new PrintPayload(); payload.append((Bitmap) null); }

public TextRow append(String text) { return append(text, null); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }

@Test(expected = IllegalArgumentException.class) public void appendNullPayloadWillThrow() { PrintPayload payload = new PrintPayload(); payload.append((PrintPayload) null); }

public TextRow append(String text) { return append(text, null); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }

@Test public void canSetFont() { PrintPayload payload = new PrintPayload(); PrinterFont printerFont = new PrinterFont(56, "FontyMcFontFace", 0, 0, false, 0, 0, null); TextRow textRow = payload.append("Hello", printerFont); assertThat(textRow.getPrinterFontId()).isEqualTo(56); }

public TextRow append(String text) { return append(text, null); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }

PrintPayload implements Jsonable { public TextRow append(String text) { return append(text, null); } PrintPayload(); PrintPayload(String printerId); TextRow append(String text); TextRow append(String text, PrinterFont printerFont); void append(PrintPayload toAppendPayload); void appendEmptyLine(); TextRow appendLineOfChar(int columns, String character); TextRow appendLeftRight(int columns, String left, String right); ImageRow append(Bitmap image); ImageRow append(Bitmap image, boolean scaleToFit); PrintRow[] getRows(); int getCodePage(); void setCodePage(int codePage); String getLanguage(); void setLanguage(String languageCode); void setPrinterId(String printerId); String getPrinterId(); boolean hasPrinterId(); @Override String toJson(); static PrintPayload fromJson(String json); }