private int getNextTableNumber(ConnectionSupplier connectionSupplier, String truncatedTableName) { AgnosticResultSet results = connectionSupplier.get().selectResultSetUnregisteredQuery( "SELECT short_table_name " + "FROM " + AtlasDbConstants.ORACLE_NAME_MAPPING_TABLE + " WHERE LOWER(short_table_name) LIKE LOWER(?||'\\_____%') ESCAPE '\\'" + " ORDER BY short_table_name DESC", truncatedTableName); return getTableNumberFromTableNames(truncatedTableName, results); }
@Override public void checkDatabaseVersion() { AgnosticResultSet result = conns.get().selectResultSetUnregisteredQuery( "SELECT version FROM product_component_version where lower(product) like '%oracle%'"); String version = result.get(0).getString("version"); if (VersionStrings.compareVersions(version, MIN_ORACLE_VERSION) < 0) { log.error("Your key value service currently uses version {}" + " of oracle. The minimum supported version is {}" + ". If you absolutely need to use an older version of oracle," + " please contact Palantir support for assistance.", version, MIN_ORACLE_VERSION); } }
@Override public void checkDatabaseVersion() { AgnosticResultSet result = conns.get().selectResultSetUnregisteredQuery("SHOW server_version"); String version = result.get(0).getString("server_version"); PostgresVersionCheck.checkDatabaseVersion(version, log); }
@Override public Set<TableReference> getAllTableNames() { return run(conn -> { AgnosticResultSet results = conn.selectResultSetUnregisteredQuery( "SELECT table_name FROM " + config.metadataTable().getQualifiedName()); Set<TableReference> ret = Sets.newHashSetWithExpectedSize(results.size()); for (AgnosticResultRow row : results.rows()) { ret.add(TableReference.createUnsafe(row.getString("table_name"))); } return ret; }); }
public TableValueStyle getTableType( final ConnectionSupplier connectionSupplier, final TableReference tableRef, TableReference metadataTable) { try { return valueStyleByTableRef.get(tableRef, () -> { SqlConnection conn = connectionSupplier.get(); AgnosticResultSet results = conn.selectResultSetUnregisteredQuery( String.format( "SELECT table_size FROM %s WHERE table_name = ?", metadataTable.getQualifiedName()), tableRef.getQualifiedName()); Preconditions.checkArgument( !results.rows().isEmpty(), "table %s not found", tableRef.getQualifiedName()); return TableValueStyle.byId(Iterables.getOnlyElement(results.rows()).getInteger("table_size")); }); } catch (ExecutionException e) { log.error("TableValueStyle for the table {} could not be retrieved.", tableRef.getQualifiedName()); throw Throwables.propagate(e); } }
@Override @SuppressWarnings("deprecation") public byte[] getMetadata() { AgnosticResultSet results = conns.get().selectResultSetUnregisteredQuery( "SELECT value FROM " + config.metadataTable().getQualifiedName() + " WHERE table_name = ?", tableRef.getQualifiedName()); if (results.size() < 1) { return PtBytes.EMPTY_BYTE_ARRAY; } else { return MoreObjects.firstNonNull( Iterables.getOnlyElement(results.rows()).getBytes("value"), PtBytes.EMPTY_BYTE_ARRAY); } }
@Before public void setup() { SqlConnection mockConnection = mock(SqlConnection.class); when(connectionSupplier.get()).thenReturn(mockConnection); AgnosticResultSet resultSet = mock(AgnosticResultSet.class); when(mockConnection.selectResultSetUnregisteredQuery(startsWith("SELECT table_size FROM"), anyObject())) .thenReturn(resultSet); AgnosticResultRow row = mock(AgnosticResultRow.class); when(row.getInteger(eq("table_size"))).thenReturn(TableValueStyle.OVERFLOW.getId()); doReturn(ImmutableList.of(row)).when(resultSet).rows(); when(mockConnection.getUnderlyingConnection()).thenReturn(mock(Connection.class)); }
private SqlConnection setUpSqlConnection(Long lastVacuumTimestamp, Long currentTimestamp) { SqlConnection sqlConnection = mock(SqlConnection.class); when(connectionSupplier.get()).thenReturn(sqlConnection); List<List<Object>> selectResults = new ArrayList<>(); selectResults.add(Arrays.asList(new Object[] {lastVacuumTimestamp, currentTimestamp})); Mockito.when(sqlConnection.selectResultSetUnregisteredQuery(startsWith("SELECT FLOOR"), any())) .thenReturn( new AgnosticResultSetImpl(selectResults, DBType.POSTGRESQL, // This is the columnName to position mapping in the results map. Column Names are both // upper-case and lower-case, as postgres allows the query to have either of them. new ImmutableMap.Builder<String, Integer>() .put("last", 0) .put("LAST", 0) .put("current", 1) .put("CURRENT", 1) .build())); return sqlConnection; }
@Override public Map<TableReference, byte[]> getMetadataForTables() { return run(conn -> { AgnosticResultSet results = conn.selectResultSetUnregisteredQuery( "SELECT table_name, value FROM " + config.metadataTable().getQualifiedName()); Map<TableReference, byte[]> ret = Maps.newHashMapWithExpectedSize(results.size()); for (AgnosticResultRow row : results.rows()) { ret.put(TableReference.createUnsafe(row.getString("table_name")), row.getBytes("value")); } return ret; }); }
@Before public void setup() { connectionSupplier = mock(ConnectionSupplier.class); oracleTableNameMapper = new OracleTableNameMapper(); SqlConnection sqlConnection = mock(SqlConnection.class); when(connectionSupplier.get()).thenReturn(sqlConnection); resultSet = mock(AgnosticResultSet.class); when(sqlConnection .selectResultSetUnregisteredQuery( startsWith("SELECT short_table_name FROM atlasdb_table_names WHERE LOWER(short_table_name)"), anyObject())) .thenReturn(resultSet); }
@SuppressWarnings("checkstyle:NestedTryDepth") public String getShortTableNameFromMappingTable( ConnectionSupplier connectionSupplier, String tablePrefix, TableReference tableRef) throws TableMappingNotFoundException { String fullTableName = tablePrefix + DbKvs.internalTableName(tableRef); try { return unmappingCache.get(fullTableName, () -> { SqlConnection conn = connectionSupplier.get(); AgnosticResultSet results = conn.selectResultSetUnregisteredQuery( "SELECT short_table_name " + "FROM " + AtlasDbConstants.ORACLE_NAME_MAPPING_TABLE + " WHERE table_name = ?", fullTableName); if (results.size() == 0) { throw new TableMappingNotFoundException( "The table " + fullTableName + " does not have a mapping." + "This might be because the table does not exist."); } return Iterables.getOnlyElement(results.rows()).getString("short_table_name"); }); } catch (ExecutionException e) { throw new TableMappingNotFoundException(e.getCause()); } }
/** * Returns the number of milliseconds since the last compaction, or Long.MAX_VALUE if * compaction has never run. */ private long getMillisSinceLastCompact() { AgnosticResultSet rs = conns.get().selectResultSetUnregisteredQuery( "SELECT FLOOR(EXTRACT(EPOCH FROM GREATEST( " + " last_vacuum, last_autovacuum, last_analyze, last_autoanalyze" + "))*1000) AS last, " + "FLOOR(EXTRACT(EPOCH FROM CURRENT_TIMESTAMP)*1000) AS current " + "FROM pg_stat_user_tables WHERE relname = ?", prefixedTableName()); AgnosticResultRow row = Iterables.getOnlyElement(rs.rows()); // last could be null if vacuum has never run long last = row.getLong("last", -1); if (last == -1) { return Long.MAX_VALUE; } long current = row.getLong("current"); return current - last; }
@Before public void setup() { connectionSupplier = mock(ConnectionSupplier.class); oracleTableNameUnmapper = new OracleTableNameUnmapper(); SqlConnection sqlConnection = mock(SqlConnection.class); Connection connection = mock(Connection.class); when(sqlConnection.getUnderlyingConnection()).thenReturn(connection); when(connectionSupplier.get()).thenReturn(sqlConnection); resultSet = mock(AgnosticResultSet.class); when(sqlConnection .selectResultSetUnregisteredQuery( startsWith("SELECT short_table_name FROM atlasdb_table_names WHERE table_name"), anyObject())) .thenReturn(resultSet); }
private void assertThatVacuumWasPerformed(SqlConnection sqlConnection, boolean assertThatTimestampsWereChecked) { assertTrue(postgresDdlTable.shouldRunCompaction()); postgresDdlTable.compactInternally(false); if (assertThatTimestampsWereChecked) { verify(sqlConnection, times(2)).selectResultSetUnregisteredQuery(startsWith("SELECT FLOOR"), any()); } verify(sqlConnection).executeUnregisteredQuery(eq("VACUUM ANALYZE " + DbKvs.internalTableName(TEST_TABLE))); }
private void assertThatVacuumWasNotPerformed(SqlConnection sqlConnection) { assertFalse(postgresDdlTable.shouldRunCompaction()); postgresDdlTable.compactInternally(false); verify(sqlConnection, times(2)).selectResultSetUnregisteredQuery(startsWith("SELECT FLOOR"), any()); verify(sqlConnection, never()).executeUnregisteredQuery( eq("VACUUM ANALYZE " + DbKvs.internalTableName(TEST_TABLE))); } }
private static SortedSetMultimap<Integer, byte[]> getRowsForBatches( Supplier<SqlConnection> connectionSupplier, String query, Object[] args) { SqlConnection connection = connectionSupplier.get(); try { AgnosticResultSet results = connection.selectResultSetUnregisteredQuery(query, args); SortedSetMultimap<Integer, byte[]> ret = TreeMultimap.create( Ordering.natural(), UnsignedBytes.lexicographicalComparator()); for (AgnosticResultRow row : results.rows()) { @SuppressWarnings("deprecation") byte[] rowName = row.getBytes("row_name"); int batchNum = row.getInteger("batch_num"); if (rowName != null) { ret.put(batchNum, rowName); } } return ret; } finally { closeSql(connection); } }
@Test public void shouldCompactIfCompactMillisIsSetToZero() throws Exception { postgresDdlTable = new PostgresDdlTable(TEST_TABLE, connectionSupplier, ImmutablePostgresDdlConfig.builder().compactInterval(HumanReadableDuration.valueOf("0 ms")).build()); SqlConnection sqlConnection = setUpSqlConnection(NOW_MILLIS - SMALL_POSITIVE_FACTOR, NOW_MILLIS); assertThatVacuumWasPerformed(sqlConnection, false); verify(sqlConnection, never()).selectResultSetUnregisteredQuery(startsWith("SELECT FLOOR"), any()); }
@Override public void checkDatabaseVersion() { AgnosticResultSet result = conns.get().selectResultSetUnregisteredQuery( "SELECT version FROM product_component_version where lower(product) like '%oracle%'"); String version = result.get(0).getString("version"); if (VersionStrings.compareVersions(version, MIN_ORACLE_VERSION) < 0) { log.error("Your key value service currently uses version {}" + " of oracle. The minimum supported version is {}" + ". If you absolutely need to use an older version of oracle," + " please contact Palantir support for assistance.", version, MIN_ORACLE_VERSION); } }
@Override public Set<TableReference> getAllTableNames() { return run(conn -> { AgnosticResultSet results = conn.selectResultSetUnregisteredQuery( "SELECT table_name FROM " + config.metadataTable().getQualifiedName()); Set<TableReference> ret = Sets.newHashSetWithExpectedSize(results.size()); for (AgnosticResultRow row : results.rows()) { ret.add(TableReference.createUnsafe(row.getString("table_name"))); } return ret; }); }
@Override public void checkDatabaseVersion() { AgnosticResultSet result = conns.get().selectResultSetUnregisteredQuery("SHOW server_version"); String version = result.get(0).getString("server_version"); PostgresVersionCheck.checkDatabaseVersion(version, log); }