target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testReverseChangeColumnName() { appleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("brand", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(), colum... | @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isA... | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isA... |
@Test public void testReverseChangeColumnNullable() { appleTable = table("Apple").columns( idColumn(), versionColumn(), column("colour", DataType.STRING, 10).nullable(), column("variety", DataType.STRING, 15).nullable(), column("ispoisoned", DataType.BOOLEAN).nullable(), column("datecreated", DataType.DATE).nullable(),... | @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isA... | ChangeColumn implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toColumn, fromColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isA... |
@Test public void testChangeMissingField() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("doesntexist", DataType.STRING, 10).nullable(), column("doesntexist", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed to chan... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@Test public void testChangeFieldIsCaseInsensitive() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("APPLE", column("VARIETY", DataType.STRING, 15).nullable(), column("Variety", DataType.STRING, 35).nullable()); Schema result = changeColumn.apply(testSchema); Table newTable = res... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@Test public void testChangeFieldNameToExistingField() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("ispoisoned", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed t... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@SuppressWarnings("unchecked") @Test public void testGetStatusWhenTableNotPresent() { when(sqlScriptExecutor.executeQuery(anyString(), any(Connection.class), any(ResultSetProcessor.class))).thenThrow(RuntimeSqlException.class); assertEquals("Result", UpgradeStatus.NONE, upgradeStatusTableService.getStatus(Optional.of(d... | @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataSource.isPresent()) { try { connection = dataSource.get().getConnectio... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... |
@Test public void testChangeFieldNameInIndex() { Schema testSchema = schema(pearTable); ChangeColumn changeColumn = new ChangeColumn("Pear", column("color", DataType.STRING, 35).nullable(), column("colour", DataType.STRING, 35).nullable()); try { changeColumn.apply(testSchema); fail("Should have failed to change name t... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@Test public void testChangePrimaryKey() { Schema testSchema = schema(appleTable); ChangeColumn changeColumn = new ChangeColumn("Apple", column("id", DataType.BIG_INTEGER).primaryKey(), column("id", DataType.BIG_INTEGER)); Schema updatedSchema = changeColumn.apply(testSchema); Table resultTable = updatedSchema.getTable... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@Test public void testCannotRenameColumnThatAppearsInIndexes() { Schema testSchema = schema(pearTable); try { new ChangeColumn("Pear", column("colour", DataType.STRING, 10).nullable(), column("hue", DataType.STRING, 10).nullable() ).apply(testSchema); fail("Expect IllegalArgumentException"); } catch(IllegalArgumentExce... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); } | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... | ChangeColumn implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromColumn, toColumn); } ChangeColumn(String tableName, Column fromColumn, Column toColumn); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApp... |
@Test public void testChangeIndexColumns() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").columns("pips"), index("Apple_1").columns("totalValue")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); as... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testAddingColumnToIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_1").columns("pips", "totalValue")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedSchema.get... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testRemovingColumnFromIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_3").unique().columns("pips")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = updatedS... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testChangeIndexName() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_4").unique().columns("colour", "pips")); Schema updatedSchema = changeIndex.apply(testSchema); Table resultTable = update... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testReverseChangeColumnType() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_3").unique().columns("colour", "pips"), index("Apple_3").columns("pips")); Schema updatedSchema = changeIndex.reverse(testSchema); Table resultTable = updatedSchema.g... | @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } | ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(S... | ChangeIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { return applyChange(schema, toIndex, fromIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(S... |
@Test public void testChangeMissingIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("doesNotExist").unique().columns("colour", "pips"), index("doesNotExist").unique().columns("colour", "pips")); try { changeIndex.apply(testSchema); fail("Should have failed to ch... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testChangeFieldNameToExistingField() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_2").unique().columns("pips")); try { changeIndex.apply(testSchema); fail("Should have failed to change name to match... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void testGetStatusWhenTablePresent() throws SQLException { ArgumentCaptor<ResultSetProcessor> captor = ArgumentCaptor.forClass(ResultSetProcessor.class); ResultSet resultSet = mock(ResultSet.class); when(sqlScriptExecutor.executeQuery(anyString(), any(Connecti... | @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataSource.isPresent()) { try { connection = dataSource.get().getConnectio... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public UpgradeStatus getStatus(Optional<DataSource> dataSource) { SelectStatement select = SqlUtils.select(SqlUtils.field(STATUS_COLUMN)).from(tableRef(UpgradeStatusTableService.UPGRADE_STATUS)); Connection connection = null; try { if (dataS... |
@Test public void testNullChangeIndex() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), null); try { changeIndex.apply(testSchema); fail("Attempting to change an index to null should result in an exception on apply"); } catch(Except... | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); } | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... | ChangeIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndex, toIndex); } ChangeIndex(String tableName, Index fromIndex, Index toIndex); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boolean isApplied(Sch... |
@Test public void testChangeIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Sweets", index("Sweets_1").unique().columns("pieces"), index("Sweets_1").unique().columns("pieces")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, toIndex)) { return true... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... |
@Test public void testChangeIndexOnExistingTable() { Schema testSchema = schema(appleTable); ChangeIndex changeIndex = new ChangeIndex("Apple", index("Apple_1").unique().columns("pips"), index("Apple_1").unique().columns("pips")); changeIndex.isApplied(testSchema, MockConnectionResources.build()); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, toIndex)) { return true... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... | ChangeIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.index... |
@Test public void testPreUpgrade() { final ArgumentCaptor<Table> captor = ArgumentCaptor.forClass(Table.class); upgrader.preUpgrade(); verify(sqlDialect).tableDeploymentStatements(captor.capture()); assertTrue("Temporary table", captor.getValue().isTemporary()); } | public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } | InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } } | InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); } | InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Over... | InlineTableUpgrader implements SchemaChangeVisitor { public void preUpgrade() { sqlStatementWriter.writeSql(sqlDialect.tableDeploymentStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUpgrade(); void postUpgrade(); @Over... |
@Test public void testPostUpgrade() { final ArgumentCaptor<Table> truncateCaptor = ArgumentCaptor.forClass(Table.class); final ArgumentCaptor<Table> dropCaptor = ArgumentCaptor.forClass(Table.class); upgrader.postUpgrade(); verify(sqlDialect).truncateTableStatements(truncateCaptor.capture()); verify(sqlDialect).dropSta... | public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } | InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } } | InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWrit... | InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWrit... | InlineTableUpgrader implements SchemaChangeVisitor { public void postUpgrade() { sqlStatementWriter.writeSql(sqlDialect.truncateTableStatements(idTable)); sqlStatementWriter.writeSql(sqlDialect.dropStatements(idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWrit... |
@Test public void testVisitAddTable() { AddTable addTable = mock(AddTable.class); given(addTable.apply(schema)).willReturn(schema); upgrader.visit(addTable); verify(addTable).apply(schema); verify(sqlDialect, atLeastOnce()).tableDeploymentStatements(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitRemoveTable() { RemoveTable removeTable = mock(RemoveTable.class); given(removeTable.apply(schema)).willReturn(schema); upgrader.visit(removeTable); verify(removeTable).apply(schema); verify(sqlDialect).dropStatements(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(Stri... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitAddIndex() { AddIndex addIndex = mock(AddIndex.class); given(addIndex.apply(schema)).willReturn(schema); upgrader.visit(addIndex); verify(addIndex).apply(schema); verify(sqlDialect).addIndexStatements(any(Table.class), any(Index.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(Str... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitAddColumn() { AddColumn addColumn = mock(AddColumn.class); given(addColumn.apply(schema)).willReturn(schema); upgrader.visit(addColumn); verify(addColumn).apply(schema); verify(sqlDialect).alterTableAddColumnStatements(any(Table.class), any(Column.class)); verify(sqlStatementWriter).writeSql(... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitChangeColumn() { ChangeColumn changeColumn = mock(ChangeColumn.class); given(changeColumn.apply(schema)).willReturn(schema); upgrader.visit(changeColumn); verify(changeColumn).apply(schema); verify(sqlDialect).alterTableChangeColumnStatements(any(Table.class), any(Column.class), any(Column.cl... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testUpdateFromNoneToInProgress() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.NONE, UpgradeStatus.IN_PROGRESS); ArgumentCaptor<Table> tableCaptor = ArgumentCaptor.forClass(Table.class); verify(sqlDialect).tableDeploymentStatements(tableCaptor.capture()); assertEquals("Table name", t... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testVisitRemoveColumn() { RemoveColumn removeColumn = mock(RemoveColumn.class); given(removeColumn.apply(schema)).willReturn(schema); upgrader.visit(removeColumn); verify(removeColumn).apply(schema); verify(sqlDialect).alterTableDropColumnStatements(any(Table.class), any(Column.class)); verify(sqlStat... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitRemoveIndex() { RemoveIndex removeIndex = mock(RemoveIndex.class); given(removeIndex.apply(schema)).willReturn(schema); upgrader.visit(removeIndex); verify(removeIndex).apply(schema); verify(sqlDialect).indexDropStatements(any(Table.class), any(Index.class)); verify(sqlStatementWriter).writeS... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitChangeIndex() { ChangeIndex changeIndex = mock(ChangeIndex.class); given(changeIndex.apply(schema)).willReturn(schema); upgrader.visit(changeIndex); verify(changeIndex).apply(schema); verify(sqlDialect).indexDropStatements(any(Table.class), any(Index.class)); verify(sqlDialect).addIndexStatem... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitInsertStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); InsertStatement insertStatement = mock(InsertStatement.class); given(executeStatement.getStatement()).willReturn(insertStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)insertStatement), any(Sc... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitUpdateStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); UpdateStatement updateStatement = mock(UpdateStatement.class); given(executeStatement.getStatement()).willReturn(updateStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)updateStatement), any(Sc... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitDeleteStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); DeleteStatement deleteStatement = mock(DeleteStatement.class); given(executeStatement.getStatement()).willReturn(deleteStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)deleteStatement), any(Sc... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitMergeStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); MergeStatement mergeStatement = mock(MergeStatement.class); given(executeStatement.getStatement()).willReturn(mergeStatement); when(sqlDialect.convertStatementToSQL(eq((Statement)mergeStatement), any(Schema.c... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testVisitStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); Statement statement = mock(Statement.class); given(executeStatement.getStatement()).willReturn(statement); when(sqlDialect.convertStatementToSQL(eq(statement), any(Schema.class), any(Table.class))).thenCallRealMet... | private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } | InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } } | InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); } | InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUp... | InlineTableUpgrader implements SchemaChangeVisitor { private void visitStatement(Statement statement) { writeStatements(sqlDialect.convertStatementToSQL(statement, currentSchema, idTable)); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatementWriter, Table idTable); void preUp... |
@Test public void testExecutePortableSqlStatement() { ExecuteStatement executeStatement = mock(ExecuteStatement.class); PortableSqlStatement statement = mock(PortableSqlStatement.class); given(executeStatement.getStatement()).willReturn(statement); DatabaseType databaseType = mock(DatabaseType.class); given(databaseTyp... | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testAnalyseTableStatment(){ AnalyseTable analyseTable = mock(AnalyseTable.class); given(analyseTable.apply(schema)).willReturn(schema); upgrader.visit(analyseTable); verify(sqlDialect).getSqlForAnalyseTable(any(Table.class)); verify(sqlStatementWriter).writeSql(anyCollectionOf(String.class)); } | @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } } | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... | InlineTableUpgrader implements SchemaChangeVisitor { @Override public void visit(AddTable addTable) { currentSchema = addTable.apply(currentSchema); writeStatements(sqlDialect.tableDeploymentStatements(addTable.getTable())); } InlineTableUpgrader(Schema startSchema, SqlDialect sqlDialect, SqlStatementWriter sqlStatemen... |
@Test public void testUpdateFromInProgressToTransferRequired() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.IN_PROGRESS, UpgradeStatus.DATA_TRANSFER_REQUIRED); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).convertStatementToSQL(stmtCap... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testRenameIndexOnNonExistentTable() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Sweets", "Sweets_1", "Sweets_2"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; } } return false; } | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... |
@Test public void testRenameIndexOnNonExistentIndex() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); assertFalse("Should not be applied", renameIndex.isApplied(testSchema, MockConnectionResources.build())); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; } } return false; } | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... | RenameIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); for (Index index : table.indexes()) { if (index.getName().equalsIgnoreCase(toIndexName)) { return true; ... |
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNoFromName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", " ", "Apple_3"); renameIndex.apply(testSchema); } | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... |
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNoToName() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", " "); renameIndex.apply(testSchema); } | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... |
@Test(expected = IllegalArgumentException.class) public void testRenameIndexNotExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_3", "Apple_4"); renameIndex.apply(testSchema); } | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... |
@Test(expected = IllegalArgumentException.class) public void testRenameIndexAlreadyExists() { Schema testSchema = schema(appleTable); RenameIndex renameIndex = new RenameIndex("Apple", "Apple_1", "Apple_2"); renameIndex.apply(testSchema); } | @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); } | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... | RenameIndex implements SchemaChange { @Override public Schema apply(Schema schema) { return applyChange(schema, fromIndexName, toIndexName); } RenameIndex(String tableName, String fromIndexName, String toIndexName); @Override void accept(SchemaChangeVisitor visitor); @Override Schema apply(Schema schema); @Override boo... |
@Test public void testAddingIndex() { Schema testSchema = schema(appleTable); Schema updatedSchema = addIndex.apply(testSchema); Table resultTable = updatedSchema.getTable("Apple"); assertNotNull(resultTable); assertEquals("Post upgrade index count", 1, resultTable.indexes().size()); assertEquals("Post upgrade index na... | @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> indexes = new ArrayList<>(); for (Index... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... |
@Test public void testReverseAddingIndex() { appleTable = table("Apple").columns( column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ).indexes( index("Apple_1").unique().columns("pips") ); Schema testSchema = schema(appleTable); Schema downGradedSchema = addIndex.reverse(te... | @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundAndRemovedIndex = true; } else { ind... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... |
@Test public void testRemovingNonExistantIndex() { Schema testSchema = schema(appleTable); try { addIndex.reverse(testSchema); fail("Should fail since index is not there"); } catch (Exception e) { } } | @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundAndRemovedIndex = true; } else { ind... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... | AddIndex implements SchemaChange { @Override public Schema reverse(Schema schema) { Table original = schema.getTable(tableName); List<String> indexeNames = new ArrayList<>(); boolean foundAndRemovedIndex = false; for (Index index : original.indexes()) { if (index.getName().equalsIgnoreCase(newIndex.getName())) { foundA... |
@Test public void testAddIndexToNonExistentTable() { Schema testSchema = schema(appleTable); addIndex = new AddIndex("Sweets", index("Sweets_1").unique().columns("pieces")); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, newIndex)) { return tru... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... |
@Test public void testUpdateFromTransferRequiredToDataTransferInProgress() { upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); ArgumentCaptor<UpdateStatement> stmtCaptor = ArgumentCaptor.forClass(UpdateStatement.class); verify(sqlDialect).con... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testAddIndexToExistingTable() { Schema testSchema = schema(appleTable); assertFalse("Index should not have been applied", addIndex.isApplied(testSchema, MockConnectionResources.build())); } | @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesMatch(index, newIndex)) { return tru... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... | AddIndex implements SchemaChange { @Override public boolean isApplied(Schema schema, ConnectionResources database) { if (!schema.tableExists(tableName)) { return false; } Table table = schema.getTable(tableName); SchemaHomology homology = new SchemaHomology(); for (Index index : table.indexes()) { if (homology.indexesM... |
@Test public void testAddIndexOfSameName() { appleTable = table("Apple").columns( column("pips", DataType.STRING, 10).nullable(), column("colour", DataType.STRING, 10).nullable() ).indexes( index("Apple_1").unique().columns("pips") ); addIndex = new AddIndex("Apple", index("Apple_1").unique().columns("pips")); Schema t... | @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> indexes = new ArrayList<>(); for (Index... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... |
@Test public void testMissingTable() { addIndex = new AddIndex("AppleX", index("Apple_1").unique().columns("pips")); Schema testSchema = schema(appleTable); try { addIndex.apply(testSchema); fail(); } catch (RuntimeException re) { assertTrue(re.getMessage(), re.getMessage().contains("Apple")); } } | @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> indexes = new ArrayList<>(); for (Index... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... | AddIndex implements SchemaChange { @Override public Schema apply(Schema schema) { Table original = schema.getTable(tableName); if (original == null) { throw new IllegalArgumentException(String.format("Cannot add index [%s] to table [%s] as the table cannot be found", newIndex.getName(), tableName)); } List<String> inde... |
@Test public void testTableExists() { assertTrue(schema.tableExists("Apple")); assertFalse(schema.tableExists("Peach")); } | @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean ... | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean ... |
@Test public void testTableExistsNotCaseSensitive() { assertTrue(schema.tableExists("APPLE")); assertTrue(schema.tableExists("apple")); } | @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); } | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean ... | TableSetSchema implements Schema { @Override public boolean tableExists(final String name) { return tables.stream().anyMatch(table -> table.getName().equalsIgnoreCase(name)); } TableSetSchema(Collection<Table> tables); @Override Collection<Table> tables(); @Override Table getTable(final String name); @Override boolean ... |
@Test public void testGetTable() { final String tableName = "Apple"; Table appleTable = schema.getTable(tableName); assertNotNull(appleTable); assertEquals(tableName, appleTable.getName()); } | @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... |
@Test public void testGetTableCaseInsensitive() { final String tableName = "Apple"; Table uppercaseTable = schema.getTable(tableName.toUpperCase()); Table lowercaseTable = schema.getTable(tableName.toLowerCase()); assertNotNull(uppercaseTable); assertNotNull(lowercaseTable); } | @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... |
@Test(expected = RuntimeException.class) public void testGetTableWhenTableDoesntExist() { final String wrongTable = "Peach"; schema.getTable(wrongTable); } | @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } } | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... | TableSetSchema implements Schema { @Override public Table getTable(final String name) { return tables.stream() .filter(table -> table.getName().equalsIgnoreCase(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Requested table [%s] does not exist.", name))); } TableSetSchema(Collection<... |
@Test public void testEscapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.escaped, escapeCharacters(testCase.unescaped)); } } | static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(String.format("\... | Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(Strin... | Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(Strin... | Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(Strin... | Escaping { static String escapeCharacters(String recordValue) { int last = 0; StringBuilder escapedValue = new StringBuilder(recordValue.length()); for (int i=0; i<recordValue.length(); i++) { if (!isCharValidForXml(recordValue.charAt(i))) { escapedValue.append(recordValue.substring(last, i)); escapedValue.append(Strin... |
@Test public void testUnescapeCharacters() { for (TestCase testCase : testCases) { assertEquals(testCase.unescaped, unescapeCharacters(testCase.escaped)); } assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\0")); assertEquals(string('a', 'b', 'c', (char) 0), unescapeCharacters("abc\u0000")); } | static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChars[i] == '\\... | Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChar... | Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChar... | Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChar... | Escaping { static String unescapeCharacters(String attributeValue) { if (attributeValue == null) return null; char[] attributeChars = attributeValue.toCharArray(); StringBuilder result = new StringBuilder(attributeChars.length); int from = 0; int len = 0; int i = 0; while (i < attributeChars.length) { if (attributeChar... |
@Test public void testUpdateFromDataTransferInProgressToCompleted() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS, UpgradeStatus.COMPLETED); ArgumentCaptor<UpdateStatement>... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void getValue() { DummyXmlOutputStreamProvider dummyXmlOutputStreamProvider = new DummyXmlOutputStreamProvider(); DataSetConsumer testConsumer = new DataMaskingXmlDataSetConsumer(dummyXmlOutputStreamProvider, toMask); Table metaData = table("Test").columns( column("id", DataType.BIG_INTEGER).primaryKey().a... | @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } | DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } } | DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } DataMasking... | DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } DataMasking... | DataMaskingXmlDataSetConsumer extends XmlDataSetConsumer { @Override protected String getValue(Record record, Column column, String table) { if (tableColumnsToMask.containsKey(table) && tableColumnsToMask.get(table).contains(column.getName())) { return null; } return super.getValue(record, column, table); } DataMasking... |
@Test public void testReadVersion() throws IOException { try (BufferedReader reader = new BufferedReader(new StringReader( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<table version=\"1\">\n" + " <metadata name=\"Foo\">" ))) { Assert.assertEquals(1, Version2to4TransformingReader.readVersion(reader)); } try (Buffe... | static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.compile("table\\sversion=\"(\\d+)\""); Matcher mat... | Version2to4TransformingReader extends Reader { static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.com... | Version2to4TransformingReader extends Reader { static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.com... | Version2to4TransformingReader extends Reader { static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.com... | Version2to4TransformingReader extends Reader { static int readVersion(BufferedReader bufferedReader) { try { bufferedReader.mark(1024); try { char[] buffer = new char[1024]; int read = bufferedReader.read(buffer); if (read == -1) { return -1; } String content = new String(buffer, 0, read); Pattern pattern = Pattern.com... |
@Test public void testCreatingAColumnTypeNotNullable() { ColumnType columnType = SchemaUtils.type(DataType.DECIMAL, 10, 4, false); assertTrue("ColumnType type incorrect", columnType.getType().equals(DataType.DECIMAL)); assertTrue("ColumnType width incorrect", columnType.getWidth() == 10); assertTrue("ColumnType scale i... | public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> ... | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> ... |
@Test public void testCreatingAColumnTypeNullable() { ColumnType columnType = SchemaUtils.type(DataType.STRING, 10, 0, true); assertTrue("ColumnType type incorrect", columnType.getType().equals(DataType.STRING)); assertTrue("ColumnType width incorrect", columnType.getWidth() == 10); assertTrue("ColumnType scale incorre... | public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); } | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> ... | SchemaUtils { public static ColumnType type(DataType type) { return SchemaUtils.column(null, type); } private SchemaUtils(); static Column idColumn(); static Column versionColumn(); static Schema schema(); static Schema schema(Table... tables); static Schema schema(View... views); static Schema schema(Iterable<Table> ... |
@Test public void testToUpperCase() { assertEquals( Arrays.asList("ONE", "TWO", "THREE"), SchemaUtils.toUpperCase(Arrays.asList("One", "two", "thReE")) ); } | public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } | SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } } | SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } private SchemaUtils(); } | SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } private SchemaUtils(); static Column idColumn(); static Colu... | SchemaUtils { public static List<String> toUpperCase(List<String> listOfStrings) { return FluentIterable.from(listOfStrings).transform(new Function<String, String>() { @Override public String apply(String value) { return value.toUpperCase(); } }).toList(); } private SchemaUtils(); static Column idColumn(); static Colu... |
@Test public void testOrdering() { assertSame("Bar table", schema1.getTable("Bar"), new CompositeSchema(schema1, schema2).getTable("Bar")); } | @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } | CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } } | CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } CompositeSchema(Schema... schema); } | CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } CompositeSchema(Schema... schema); @Override boolean isEmptyDatabase(); @Ov... | CompositeSchema implements Schema { @Override public Table getTable(String name) { for (Schema schema : delegates) if (schema.tableExists(name)) return schema.getTable(name); throw new IllegalArgumentException("Unknown table [" + name + "]"); } CompositeSchema(Schema... schema); @Override boolean isEmptyDatabase(); @Ov... |
@Test public void testColumnWithName() { String columnName = "columnName"; Table table = table("tableName").columns( idColumn(), versionColumn(), column(columnName, DataType.STRING, 10).nullable() ); assertEquals("Incorrect column", TableHelper.columnWithName(table, columnName).getName(), columnName); } | public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } | TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } } | TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } } | TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> build... | TableHelper { public static Column columnWithName(Table table, String columnName) { for (Column currentColumn : table.columns()) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { return currentColumn; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> build... |
@Test public void testIndexWithName() { String indexName = "indexName"; Table table = table("tableName").indexes(index(indexName)); assertEquals("Incorrect index", TableHelper.indexWithName(table, indexName).getName(), indexName); } | public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } | TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } } | TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } } | TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNa... | TableHelper { public static Index indexWithName(Table table, String indexName) { for (Index currentIndex : table.indexes()) { if (currentIndex.getName().equalsIgnoreCase(indexName)) { return currentIndex; } } return null; } static Column columnWithName(Table table, String columnName); static List<String> buildColumnNa... |
@Test public void testBuildColumnNameList() { Table table = table("tableName").columns( idColumn(), versionColumn(), column("columnName1", DataType.STRING, 10).nullable(), column("columnName2", DataType.STRING, 10).nullable() ); assertEquals("Column list", Arrays.asList("id", "version", "columnName1", "columnName2"), T... | public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } | TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } } | TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } } | TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } static Column columnWithName(Table table, String columnName); static List<String> buildColumn... | TableHelper { public static List<String> buildColumnNameList(Table table) { List<String> result = new ArrayList<String>(); for (Column currentColumn : table.columns()) { result.add(currentColumn.getName()); } return result; } static Column columnWithName(Table table, String columnName); static List<String> buildColumn... |
@Test public void testValidSchema() { Schema validSchema = schema(simpleValidTable, edgeCaseValidTable); SchemaValidator validator = new SchemaValidator(); validator.validate(validSchema); } | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testUpdateFromDataTransferRequiredToCompleted() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_REQUIRED); upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); ArgumentCaptor<UpdateStatement> stmtCap... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testInvalidTableName() { Schema invalidTableNameSchema = schema(simpleValidTable, invalidTableNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidTableNameSchema); fail("Expected a RuntimeException for an invalid table name"); } catch (RuntimeException e) { a... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testValidTableNames() { SchemaValidator validator = new SchemaValidator(); validator.validate( table("Table_with_underscores").columns( column("id", DataType.BIG_INTEGER).primaryKey() ) ); } | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testValidViewNames() { SchemaValidator validator = new SchemaValidator(); validator.validate(view("View_with_underscores", null)); validator.validate(view(EDGE_CASE_VALID_NAME_30_CHARACTERS, null)); validator.validate(view("ABCDEFGHIJKLMNOPQRSTUVWXYZ", null)); validator.validate(view("abcdefghijklmnop... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidViewNames() { try { SchemaValidator validator = new SchemaValidator(); validator.validate(view(INVALID_NAME_31_CHARACTERS, null)); fail("should have thrown an exception"); } catch (RuntimeException e) { assertTrue("Expected [ " + INVALID_NAME_31_CHARACTERS + "] in error message", e.getMessa... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testValidViewColumnNames() { SchemaValidator validator = new SchemaValidator(); TableReference table = tableRef("Foo"); SelectStatement selectStatement = select(table.field(EDGE_CASE_VALID_NAME_30_CHARACTERS), table.field("Column_with_underscores"), table.field("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), table.fie... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidViewColumnNames() { final String columnWithBadCharacters = "Column_with?!"; final String columnWithReservedWords = "operator"; try { TableReference table = tableRef("Foo"); SelectStatement selectStatement = select(table.field(INVALID_NAME_31_CHARACTERS), table.field(columnWithBadCharacters)... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidIndexName() { Schema invalidIndexNameSchema = schema(simpleValidTable, invalidIndexNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidIndexNameSchema); fail("Expected a RuntimeException for an invalid index name"); } catch (RuntimeException e) { a... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidColumnName() { Schema invalidColumnNameSchema = schema(simpleValidTable, invalidColumnNameTable); try { SchemaValidator validator = new SchemaValidator(); validator.validate(invalidColumnNameSchema); fail("Expected a RuntimeException for an invalid column name"); } catch (RuntimeException e... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testIndexesThatDuplicatesId() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING).nullable() ).indexes( index("badIndex").unique().columns("id") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an invalid index: [ba... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testDuplicateIndexes() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING).nullable(), column("column2", DataType.STRING).nullable() ).indexes( index("index1").unique().columns("column1", "column2"), index("index2").unique().columns("column1", "column2") ... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testUpdateFromDataTransferRequiredToCompletedFail() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.DATA_TRANSFER_IN_PROGRESS); int result = upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); assertEquals("Resul... | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testGetRecords() throws URISyntaxException { final SpreadsheetDataSetProducer producer = produceTestSpreadsheet(); List<Record> records = Lists.newArrayList(producer.records("UsageMeterType")); assertEquals("Number of rows [" + records + "]", 2, records.size()); Record record = records.get(0); assertE... | private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i, row).getContents()), i); } final int translationColumn... | SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i... | SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i... | SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i... | SpreadsheetDataSetProducer implements DataSetProducer { private List<Record> getRecords(Sheet sheet) { try { long id = 1; int row = findHeaderRow(sheet); final Map<String, Integer> columnHeadingsMap = new HashMap<>(); for (int i = 0; i < countHeadings(sheet, row); i++) { columnHeadingsMap.put(columnName(sheet.getCell(i... |
@Test public void testIndexesThatDuplicatesPrimaryIndex() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING, 15).primaryKey() ).indexes( index("index1").unique().columns("column1") ) ); try { new SchemaValidator().validate(schema); fail("Expected a RuntimeException for an... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testIndexesThatDuplicatesCompositePrimaryIndex() { Schema schema = schema( table("SomeValidTableName") .columns( column("column1", DataType.STRING, 15).primaryKey(), column("column2", DataType.STRING, 15).primaryKey(), column("column3", DataType.STRING, 15) ).indexes( index("index1").unique().columns(... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidColumnWidthTable() { Schema schema = schema(table("InvalidColumnWidthTable") .columns( column("myName", DataType.STRING, 20).nullable(), column("dateOfBirth", DataType.DECIMAL, 8).nullable(), column("gender", DataType.STRING, 0).nullable(), column("vo2Max", DataType.DECIMAL, 0).nullable(), ... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testInvalidPrimaryKeyAndNullableColumn() { Table invalidPkAndNullable = table("InvalidColumn") .columns( column("pkandnullable", DataType.STRING, 10).nullable().primaryKey() ); try { new SchemaValidator().validate(schema(invalidPkAndNullable)); fail(); } catch (RuntimeException e) { assertTrue(e.getMe... | public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } | SchemaValidator { public void validate(Schema schema) { for (Table table : schema.tables()) { validateTable(table); } for (View view : schema.views()) { validateView(view); } checkForValidationErrors(); } void validate(Schema schema); void validate(Table table); void validate(View view); } |
@Test public void testDuplicate() { boolean match = schemaHomology.tablesMatch(appleTable, appleTableDuplicate); assertTrue(match); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testNameChange() { assertFalse(schemaHomology.tablesMatch(appleTable, appleNameChange)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testAutonumbering() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableNotAutonumbered)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testCaseInsensitivity() { boolean match = schemaHomology.tablesMatch(appleTable, appleTableChangeCase); assertTrue(match); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testExtraColumn() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableWithExtraColumn)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testMissingColumn() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableWithMissingColumn)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testUpdateFromDataTransferRequiredToCompletedNone() { when(sqlScriptExecutor.executeQuery(any(), any())).thenReturn(UpgradeStatus.NONE); int result = upgradeStatusTableService.writeStatusFromStatus(UpgradeStatus.DATA_TRANSFER_REQUIRED, UpgradeStatus.COMPLETED); assertEquals("Result", 0, result); } | @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e) { UpgradeStatus currentStatus = getStatus(Optional.empty()); log.deb... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... | UpgradeStatusTableServiceImpl implements UpgradeStatusTableService { @Override public int writeStatusFromStatus(UpgradeStatus fromStatus, UpgradeStatus toStatus) { List<String> script = updateTableScript(fromStatus, toStatus); try { return sqlScriptExecutorProvider.get().execute(script); } catch (RuntimeSqlException e)... |
@Test public void testRenameColumn() { assertFalse("Renamed column should cause tables to be different", schemaHomology.tablesMatch(appleTable, appleTableWithRenamedColumn)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testMissingIndex() { assertFalse("Missing index should cause tables to be different", schemaHomology.tablesMatch(appleTable, appleTableMissingIndex)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testRenamedIndex() { assertFalse(schemaHomology.tablesMatch(appleTable, appleTableRenamedIndex)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testModifyWidth() { assertFalse(schemaHomology.tablesMatch(pearTable, pearTableModifiedWidth)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
@Test public void testModifyScale() { assertFalse(schemaHomology.tablesMatch(pearTable, pearTableModifiedScale)); } | public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); } | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... | SchemaHomology { public boolean tablesMatch(Table table1, Table table2) { noDifferences = true; checkTable(table1, table2); return noDifferences; } SchemaHomology(); SchemaHomology(DifferenceWriter differenceWriter); SchemaHomology(DifferenceWriter differenceWriter, String schema1Name, String schema2Name); boolean sc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.