private void executeIgnoringError(String sql, String errorToIgnore) { try { connectionSupplier.get().executeUnregisteredQuery(sql); } catch (PalantirSqlException e) { if (!e.getMessage().contains(errorToIgnore)) { log.error("Error occurred trying to execute the query {}", sql, e); throw e; } } } }
private static void closeSql(SqlConnection conn) { Connection underlyingConnection = conn.getUnderlyingConnection(); if (underlyingConnection != null) { try { underlyingConnection.close(); } catch (Exception e) { log.debug("Error occurred trying to close the sql connection", e); } } }
@Override public Long get() { if (currentIdIndex < OVERFLOW_ID_CACHE_SIZE) { return currentBatchStartId + currentIdIndex++; } currentBatchStartId = conns.get() .selectLongUnregisteredQuery( "SELECT " + tablePrefix + AtlasDbConstants.ORACLE_OVERFLOW_SEQUENCE + ".NEXTVAL FROM DUAL"); currentIdIndex = 0; return currentBatchStartId + currentIdIndex++; } }
@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 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))); }
@Override public void create(byte[] tableMetadata) { if (conns.get().selectExistsUnregisteredQuery( "SELECT 1 FROM " + config.metadataTable().getQualifiedName() + " WHERE table_name = ?", tableName.getQualifiedName())) { conns.get().executeUnregisteredQuery( String.format("CREATE TABLE %s (" + " row_name BYTEA NOT NULL," ignoringError(() -> conns.get().insertOneUnregisteredQuery( String.format( "INSERT INTO %s (table_name, table_size) VALUES (?, ?)",
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); }
log.info("Got connection for delete on table {}: {}, autocommit={}", shortTableName, conn.getUnderlyingConnection(), conn.getUnderlyingConnection().getAutoCommit()); } catch (PalantirSqlException | SQLException e) { conn.updateManyUnregisteredQuery(" /* DELETE_ONE (" + shortTableName + ") */ " + " DELETE /*+ INDEX(m " + PrimaryKeyConstraintNames.get(shortTableName) + ") */ " + " FROM " + shortTableName + " m "
public ClosableIterator<AgnosticLightResultRow> getRowsColumnRange( Map<byte[], BatchColumnRangeSelection> columnRangeSelectionsByRow, long ts) { if (columnRangeSelectionsByRow.isEmpty()) { return ClosableIterators.emptyImmutableClosableIterator(); } else { FullQuery query = queryFactory.getRowsColumnRangeQuery(columnRangeSelectionsByRow, ts); AgnosticLightResultSet results = conns.get().selectLightResultSetUnregisteredQuery(query.getQuery(), query.getArgs()); int totalSize = columnRangeSelectionsByRow.values().stream().mapToInt( BatchColumnRangeSelection::getBatchHint).sum(); results.setFetchSize(Math.min(totalSize, MAX_ROW_COLUMN_RANGES_FETCH_SIZE)); return ClosableIterators.wrap(results.iterator(), results); } }
@Override public void delete(List<Entry<Cell, Long>> entries) { List<Object[]> args = Lists.newArrayListWithCapacity(entries.size()); for (Map.Entry<Cell, Long> entry : entries) { Cell cell = entry.getKey(); args.add(new Object[] {cell.getRowName(), cell.getColumnName(), entry.getValue()}); } String prefixedTableName = prefixedTableNames.get(tableRef, conns); conns.get().updateManyUnregisteredQuery(" /* DELETE_ONE (" + prefixedTableName + ") */ " + " DELETE /*+ INDEX(m " + PrimaryKeyConstraintNames.get(prefixedTableName) + ") */ " + " FROM " + prefixedTableName + " m " + " WHERE m.row_name = ? " + " AND m.col_name = ? " + " AND m.ts = ?", args); }
private void put(List<Object[]> args, List<Object[]> overflowArgs) { if (!overflowArgs.isEmpty()) { if (config.overflowMigrationState() == OverflowMigrationState.UNSTARTED) { conns.get().insertManyUnregisteredQuery("/* INSERT_OVERFLOW */" + " INSERT INTO " + config.singleOverflowTable() + " (id, val) VALUES (?, ?) ", overflowArgs); } else { String shortOverflowTableName = getShortOverflowTableName(); conns.get().insertManyUnregisteredQuery( "/* INSERT_OVERFLOW (" + shortOverflowTableName + ") */" + " INSERT INTO " + shortOverflowTableName + " (id, val) VALUES (?, ?) ", overflowArgs); } } try { String shortTableName = oraclePrefixedTableNames.get(tableRef, conns); conns.get().insertManyUnregisteredQuery("/* INSERT_ONE (" + shortTableName + ") */" + " INSERT INTO " + shortTableName + " (row_name, col_name, ts, val, overflow) " + " VALUES (?, ?, ?, ?, ?) ", args); } catch (PalantirSqlException e) { if (ExceptionCheck.isUniqueConstraintViolation(e)) { throw new KeyAlreadyExistsException("primary key violation", e); } throw e; } }
private boolean overflowColumnExists(String shortTableName) { // All table names in user_tab_cols are upper case return conns.get().selectExistsUnregisteredQuery( "SELECT 1 FROM user_tab_cols WHERE TABLE_NAME = ? AND COLUMN_NAME = 'OVERFLOW'", shortTableName.toUpperCase()); }
private AgnosticLightResultSet executeQuery(SqlConnection conn, FullQuery query) { return conn.selectLightResultSetUnregisteredQueryWithFetchSize( query.getQuery(), sqlRowLimit, query.getArgs()); }
private void insertTableMappingIgnoringPrimaryKeyViolation(String fullTableName, String shortTableName) { try { conns.get().insertOneUnregisteredQuery( "INSERT INTO " + AtlasDbConstants.ORACLE_NAME_MAPPING_TABLE + " (table_name, short_table_name) VALUES (?, ?)", fullTableName, shortTableName); } catch (PalantirSqlException ex) { if (!isPrimaryKeyViolation(ex)) { log.error("Error occurred trying to create table mapping {} -> {}", fullTableName, shortTableName, ex); dropTableInternal(fullTableName, shortTableName); throw ex; } } }
@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); } }
log.info("Got connection for deleteAllTimestamps on table {}: {}, autocommit={}", shortTableName, conn.getUnderlyingConnection(), conn.getUnderlyingConnection().getAutoCommit()); } catch (PalantirSqlException | SQLException e) { conn.updateManyUnregisteredQuery(" /* DELETE_ALL_TS (" + shortTableName + ") */ " + " DELETE /*+ INDEX(m " + PrimaryKeyConstraintNames.get(shortTableName) + ") */ " + " FROM " + shortTableName + " m "
@Override public void create(byte[] tableMetadata) { if (conns.get().selectExistsUnregisteredQuery( "SELECT 1 FROM " + config.metadataTable().getQualifiedName() + " WHERE table_name = ?", tableName.getQualifiedName())) { conns.get().executeUnregisteredQuery( String.format("CREATE TABLE %s (" + " row_name BYTEA NOT NULL," ignoringError(() -> conns.get().insertOneUnregisteredQuery( String.format( "INSERT INTO %s (table_name, table_size) VALUES (?, ?)",
@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 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))); } }
public ClosableIterator<AgnosticLightResultRow> getRowsColumnRangeCounts( List<byte[]> rows, long ts, ColumnRangeSelection columnRangeSelection) { if (rows.isEmpty()) { return ClosableIterators.emptyImmutableClosableIterator(); } else { FullQuery query = queryFactory.getRowsColumnRangeCountsQuery(rows, ts, columnRangeSelection); AgnosticLightResultSet results = conns.get() .selectLightResultSetUnregisteredQuery(query.getQuery(), query.getArgs()); results.setFetchSize(Math.min(rows.size(), MAX_ROW_COLUMN_RANGES_FETCH_SIZE)); return ClosableIterators.wrap(results.iterator(), results); } }