private TableReference getTableRef(String tableName) { return TableReference.createUnsafe(tableName); } }
@SuppressWarnings("checkstyle:RegexpSinglelineJava") static TableReference tableReferenceFromBytes(byte[] name) { return TableReference.createUnsafe(new String(name, Charset.defaultCharset())); }
@SuppressWarnings("checkstyle:RegexpSinglelineJava") static TableReference lowerCaseTableReferenceFromBytes(byte[] name) { return TableReference.createUnsafe(new String(name, Charset.defaultCharset()).toLowerCase()); }
/** * @deprecated uses {@link TableReference#createUnsafe}, which is itself deprecated. */ @Deprecated public static TableReference fromInternalTableName(String tableName) { if (tableName.startsWith("_")) { return createWithEmptyNamespace(tableName); } return createUnsafe(tableName.replaceFirst("__", ".")); }
public static TableReference appendIndexSuffix(String indexName, IndexDefinition definition) { Preconditions.checkArgument( !indexName.endsWith(INDEX_SUFFIX), "Index name cannot end with '%s': %s", INDEX_SUFFIX, indexName); return TableReference.createUnsafe(indexName + definition.getIndexType().getIndexSuffix()); }
public static TableReference getIndexTableFromValueTable(TableReference tableReference) { Preconditions.checkArgument(isStreamStoreValueTable(tableReference), "tableReference should be a StreamStore value table"); int tableNameLastIndex = tableReference.getQualifiedName().lastIndexOf(StreamTableType.VALUE.tableSuffix); String indexTableName = tableReference.getQualifiedName().substring(0, tableNameLastIndex) + INDEX.tableSuffix; return TableReference.createUnsafe(indexTableName); } }
private void compactTable(String tableToCompact, CompactorConfig config) { // System tables MAY be involved in this process. keyValueService.compactInternally(TableReference.createUnsafe(tableToCompact), config.inMaintenanceMode()); }
@Override public TableMetadata load(String tableName) throws Exception { byte[] rawMetadata = kvs.getMetadataForTable(TableReference.createUnsafe(tableName)); if (rawMetadata == null || rawMetadata.length == 0) { return EMPTY; } return TableMetadata.BYTES_HYDRATOR.hydrateFromBytes(rawMetadata); } });
private static void logMismatch(String fieldName, String tableName, Object clientSideVersion, Object clusterSideVersion) { log.info("Found client/server disagreement on {} for table {}. (client = ({}), server = ({}))", SafeArg.of("disagreementType", fieldName), LoggingArgs.tableRef(TableReference.createUnsafe(tableName)), SafeArg.of("clientVersion", clientSideVersion), SafeArg.of("clusterVersion", clusterSideVersion)); }
private Set<TableReference> getAllTableNames(DSLContext ctx) { Result<? extends Record> records = ctx .select(TABLE_NAME) .from(METADATA_TABLE) .fetch(); Set<TableReference> tableRefs = Sets.newHashSetWithExpectedSize(records.size()); for (Record record : records) { tableRefs.add(TableReference.createUnsafe(record.getValue(TABLE_NAME))); } return tableRefs; }
@Test public void shouldAllowSameTablenameDifferentNamespace() { TableReference fooBar = TableReference.createUnsafe("foo.bar"); TableReference bazBar = TableReference.createUnsafe("baz.bar"); // try create table in same call keyValueService.createTables( ImmutableMap.of( fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA, bazBar, AtlasDbConstants.GENERIC_TABLE_METADATA)); // try create table spanned over different calls keyValueService.createTable(fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.createTable(bazBar, AtlasDbConstants.GENERIC_TABLE_METADATA); // test tables actually created assertThat(keyValueService.getAllTableNames(), hasItems(fooBar, bazBar)); // clean up keyValueService.dropTables(ImmutableSet.of(fooBar, bazBar)); }
@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 Map<TableReference, byte[]> getMetadataForTables() { return run(ctx -> { Result<? extends Record> records = ctx .select(TABLE_NAME, METADATA) .from(METADATA_TABLE) .fetch(); Map<TableReference, byte[]> metadata = Maps.newHashMapWithExpectedSize(records.size()); for (Record record : records) { metadata.put(TableReference.createUnsafe(record.getValue(TABLE_NAME)), record.getValue(METADATA)); } return metadata; }); }
@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; }); }
@Test public void truncateShouldBeIdempotent() { TableReference fooBar = TableReference.createUnsafe("foo.bar"); keyValueService.createTable(fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.truncateTable(fooBar); keyValueService.truncateTable(fooBar); keyValueService.dropTable(fooBar); }
TableReference tableToSweep = TableReference.createUnsafe(table); if (!services.getKeyValueService().getAllTableNames().contains(tableToSweep)) { printer.info("The table {} passed in to sweep does not exist", LoggingArgs.tableRef(tableToSweep));
private static SweepPriority hydrate(SweepPriorityTable.SweepPriorityRowResult rr) { return ImmutableSweepPriority.builder() .tableRef(TableReference.createUnsafe(rr.getRowName().getFullTableName())) .writeCount(rr.hasWriteCount() ? rr.getWriteCount() : 0L) .lastSweepTimeMillis(rr.hasLastSweepTime() ? OptionalLong.of(rr.getLastSweepTime()) : OptionalLong.empty()) .minimumSweptTimestamp(rr.hasMinimumSweptTimestamp() ? rr.getMinimumSweptTimestamp() : Long.MIN_VALUE) .staleValuesDeleted(rr.hasCellsDeleted() ? rr.getCellsDeleted() : 0L) .cellTsPairsExamined(rr.hasCellsExamined() ? rr.getCellsExamined() : 0L) .build(); }
@SuppressWarnings("checkstyle:RegexpSinglelineJava") static TableReference tableReferenceFromBytes(byte[] name) { return TableReference.createUnsafe(new String(name, Charset.defaultCharset())); }
@Override public int execute(AtlasDbServices services) { // test a method on each of the services if (flag1 != null) { services.getKeyValueService().getAllTableNames(); services.getTimestampService().getFreshTimestamp(); services.getLockService().getMinLockedInVersionId("test-client"); services.getTransactionManager().getImmutableTimestamp(); } // test kvs create table if (flag2 != null) { TableReference table = TableReference.createUnsafe(flag2); services.getKeyValueService().createTable(table, AtlasDbConstants.GENERIC_TABLE_METADATA); Preconditions.checkArgument(services.getKeyValueService().getAllTableNames().contains(table), "kvs contains tables %s, but not table %s", services.getKeyValueService().getAllTableNames(), table.getQualifiedName()); services.getKeyValueService().dropTable(table); } return 0; }
@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; }); }