return 1;
}
+ @Override
+ public boolean supportsUpsert() {
+ return false;
+ }
+
Version checkDbVersion(DatabaseMetaData metaData, Version minSupported) throws SQLException {
int major = metaData.getDatabaseMajorVersion();
int minor = metaData.getDatabaseMinorVersion();
*/
boolean supportsMigration();
+ boolean supportsUpsert();
+
/**
* This method is called when connecting for the first
* time to the database.
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.utils.Version;
+import org.sonar.api.utils.log.Loggers;
+
+import static com.google.common.base.Preconditions.checkState;
public class PostgreSql extends AbstractDialect {
public static final String ID = "postgresql";
static final List<String> INIT_STATEMENTS = ImmutableList.of("SET standard_conforming_strings=on", "SET backslash_quote=off");
private static final Version MIN_SUPPORTED_VERSION = Version.create(9, 3, 0);
+ private static final Version MIN_UPSERT_VERSION = Version.create(9, 5, 0);
+
+ private boolean initialized = false;
+ private boolean supportsUpsert = false;
public PostgreSql() {
super(ID, "org.postgresql.Driver", "true", "false", "SELECT 1");
return true;
}
+ @Override
+ public boolean supportsUpsert() {
+ checkState(initialized, "onInit() must be called before calling supportsUpsert()");
+ return supportsUpsert;
+ }
+
@Override
public void init(DatabaseMetaData metaData) throws SQLException {
- checkDbVersion(metaData, MIN_SUPPORTED_VERSION);
+ checkState(!initialized, "onInit() must be called once");
+
+ Version version = checkDbVersion(metaData, MIN_SUPPORTED_VERSION);
+
+ supportsUpsert = version.compareTo(MIN_UPSERT_VERSION) >= 0;
+ if (!supportsUpsert) {
+ Loggers.get(getClass()).warn("Upgrading PostgreSQL to {} or greater is recommended for better performances", MIN_UPSERT_VERSION);
+ }
+
+ initialized = true;
}
}
assertThat(logs.logs(LoggerLevel.WARN)).contains("H2 database should be used for evaluation purpose only.");
}
+
+ @Test
+ public void supportsUpsert_returns_false() {
+ assertThat(underTest.supportsUpsert()).isFalse();
+ }
}
underTest.init(metadata);
}
+ @Test
+ public void supportsUpsert_returns_false() {
+ assertThat(underTest.supportsUpsert()).isFalse();
+ }
+
private DatabaseMetaData newMetadata(int dbMajorVersion, int dbMinorVersion) throws SQLException {
DatabaseMetaData metadata = mock(DatabaseMetaData.class, Mockito.RETURNS_DEEP_STUBS);
when(metadata.getDatabaseMajorVersion()).thenReturn(dbMajorVersion);
assertThat(logs.logs(LoggerLevel.WARN)).contains("MySQL support is deprecated and will be dropped soon.");
}
+ @Test
+ public void supportsUpsert_returns_false() {
+ assertThat(underTest.supportsUpsert()).isFalse();
+ }
+
private DatabaseMetaData newMetadata(int dbMajorVersion, int dbMinorVersion) throws SQLException {
DatabaseMetaData metadata = mock(DatabaseMetaData.class, Mockito.RETURNS_DEEP_STUBS);
when(metadata.getDatabaseMajorVersion()).thenReturn(dbMajorVersion);
}
}
+ @Test
+ public void supportsUpsert_returns_false() {
+ assertThat(underTest.supportsUpsert()).isFalse();
+ }
+
private DatabaseMetaData newMetadata(int dbMajorVersion, int dbMinorVersion, String driverVersion) throws SQLException {
DatabaseMetaData metadata = mock(DatabaseMetaData.class, Mockito.RETURNS_DEEP_STUBS);
when(metadata.getDatabaseMajorVersion()).thenReturn(dbMajorVersion);
import org.junit.rules.ExpectedException;
import org.mockito.Mockito;
import org.sonar.api.utils.MessageException;
+import org.sonar.api.utils.log.LogTester;
+import org.sonar.api.utils.log.LoggerLevel;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
@Rule
public ExpectedException expectedException = ExpectedException.none();
+ @Rule
+ public LogTester logs = new LogTester();
private PostgreSql underTest = new PostgreSql();
}
@Test
- public void init_throws_MessageException_if_postgresql_9_2() throws Exception {
+ public void postgresql_9_2_is_not_supported() throws Exception {
expectedException.expect(MessageException.class);
expectedException.expectMessage("Unsupported postgresql version: 9.2. Minimal supported version is 9.3.");
}
@Test
- public void init_does_not_fail_if_postgresql_9_3() throws Exception {
+ public void postgresql_9_3_is_supported_without_upsert() throws Exception {
DatabaseMetaData metadata = newMetadata( 9, 3);
underTest.init(metadata);
+
+ assertThat(underTest.supportsUpsert()).isFalse();
+ assertThat(logs.logs(LoggerLevel.WARN)).contains("Upgrading PostgreSQL to 9.5 or greater is recommended for better performances");
+ }
+
+ @Test
+ public void postgresql_9_5_is_supported_with_upsert() throws Exception {
+ DatabaseMetaData metadata = newMetadata( 9, 5);
+ underTest.init(metadata);
+
+ assertThat(underTest.supportsUpsert()).isTrue();
+ assertThat(logs.logs(LoggerLevel.WARN)).isEmpty();
+ }
+
+ @Test
+ public void init_throws_ISE_if_called_twice() throws Exception {
+ DatabaseMetaData metaData = newMetadata(9, 5);
+ underTest.init(metaData);
+
+ expectedException.expect(IllegalStateException.class);
+ expectedException.expectMessage("onInit() must be called once");
+
+ underTest.init(metaData);
+ }
+
+ @Test
+ public void supportsUpsert_throws_ISE_if_not_initialized() {
+ expectedException.expect(IllegalStateException.class);
+ expectedException.expectMessage("onInit() must be called before calling supportsUpsert()");
+
+ underTest.supportsUpsert();
}
private DatabaseMetaData newMetadata(int dbMajorVersion, int dbMinorVersion) throws SQLException {