@Override public List<PTable> getIndexes() { return delegate.getIndexes(); }
private boolean execeededIndexQuota(PTableType tableType, PTable parentTable) { return PTableType.INDEX == tableType && parentTable.getIndexes().size() >= maxIndexesPerTable; }
/** * For client-side to serialize all IndexMaintainers for a given table * @param dataTable data table * @param ptr bytes pointer to hold returned serialized value */ public static void serialize(PTable dataTable, ImmutableBytesWritable ptr, PhoenixConnection connection) { List<PTable> indexes = dataTable.getIndexes(); serializeServerMaintainedIndexes(dataTable, ptr, indexes, connection); }
public static boolean hasGlobalIndex(PTable table) { for (PTable index : table.getIndexes()) { if (index.getIndexType() == IndexType.GLOBAL) { return true; } } return false; }
private List<PTable> getClientSideMaintainedIndexes(TableRef tableRef) { PTable table = tableRef.getTable(); if (!table.getIndexes().isEmpty()) { List<PTable> nonDisabledIndexes = Lists.newArrayListWithExpectedSize(table.getIndexes().size()); for (PTable index : table.getIndexes()) { if (index.getIndexState() != PIndexState.DISABLE && isMaintainedOnClient(index)) { nonDisabledIndexes.add(index); } } return nonDisabledIndexes; } return Collections.emptyList(); }
public static IndexMaintainer create(PTable dataTable, PTable index, PhoenixConnection connection) { if (dataTable.getType() == PTableType.INDEX || index.getType() != PTableType.INDEX || !dataTable.getIndexes().contains(index)) { throw new IllegalArgumentException(); } IndexMaintainer maintainer = new IndexMaintainer(dataTable, index, connection); return maintainer; }
public static List<PTable> getClientMaintainedIndexes(PTable table) { Iterator<PTable> indexIterator = // Only maintain tables with immutable rows through this client-side mechanism (table.isTransactional() && table.getTransactionProvider().getTransactionProvider().isUnsupported(Feature.MAINTAIN_LOCAL_INDEX_ON_SERVER)) ? IndexMaintainer.maintainedIndexes(table.getIndexes().iterator()) : (table.isImmutableRows() || table.isTransactional()) ? IndexMaintainer.maintainedGlobalIndexes(table.getIndexes().iterator()) : Collections.<PTable>emptyIterator(); return Lists.newArrayList(indexIterator); }
@Override public MetaDataMutationResult updateIndexState(final List<Mutation> tableMetaData, String parentTableName, Map<String, List<Pair<String,Object>>> stmtProperties, PTable table) throws SQLException { if(stmtProperties == null) { return updateIndexState(tableMetaData,parentTableName); } Map<TableDescriptor, TableDescriptor> oldToNewTableDescriptors = separateAndValidateProperties(table, stmtProperties, new HashSet<>(), new HashMap<>()); TableDescriptor origTableDescriptor = this.getTableDescriptor(table.getPhysicalName().getBytes()); TableDescriptor newTableDescriptor = oldToNewTableDescriptors.remove(origTableDescriptor); Set<TableDescriptor> modifiedTableDescriptors = Collections.emptySet(); if (newTableDescriptor != null) { modifiedTableDescriptors = Sets.newHashSetWithExpectedSize(3 + table.getIndexes().size()); modifiedTableDescriptors.add(newTableDescriptor); } sendHBaseMetaData(modifiedTableDescriptors, true); return updateIndexState(tableMetaData, parentTableName); }
private static void syncUpdateCacheFreqForIndexesOfTable(PTable baseTable, PreparedStatement stmt) throws SQLException { for (PTable index : baseTable.getIndexes()) { if (index.getUpdateCacheFrequency() == baseTable.getUpdateCacheFrequency()) { continue; } stmt.setString(2, index.getSchemaName().getString()); stmt.setString(3, index.getTableName().getString()); stmt.setLong(4, baseTable.getUpdateCacheFrequency()); stmt.addBatch(); } }
/** * Get the index tables of current data table * @throws java.sql.SQLException */ private List<TargetTableRef> getIndexTables(Connection conn, String schemaName, String qualifiedTableName) throws SQLException { PTable table = PhoenixRuntime.getTable(conn, qualifiedTableName); List<TargetTableRef> indexTables = new ArrayList<TargetTableRef>(); for(PTable indexTable : table.getIndexes()){ indexTables.add(new TargetTableRef(indexTable.getName().getString(), indexTable .getPhysicalName().getString())); } return indexTables; }
QueryUtil.getConnectionOnServer(compactionConfig).unwrap(PhoenixConnection.class)) { PTable table = PhoenixRuntime.getTableNoCache(conn, fullTableName); List<PTable> indexes = PTableType.INDEX.equals(table.getType()) ? Lists.newArrayList(table) : table.getIndexes();
/** * Synchronize certain properties across column families of global index tables for a given base table * @param cqs CQS object to get table descriptor from PTable * @param baseTable base table * @param defaultColFam column family to be used for synchronizing properties * @param syncedProps Map of properties to be kept in sync as read from the default column family descriptor * @param tableDescsToSync set of modified table descriptors */ private static void syncGlobalIndexesForTable(ConnectionQueryServices cqs, PTable baseTable, ColumnFamilyDescriptor defaultColFam, Map<String, Object> syncedProps, Set<TableDescriptor> tableDescsToSync) throws SQLException { for (PTable indexTable: baseTable.getIndexes()) { // We already handle local index property synchronization when considering all column families of the base table if (indexTable.getIndexType() == IndexType.GLOBAL) { addTableDescIfPropsChanged(cqs.getTableDescriptor(indexTable.getPhysicalName().getBytes()), defaultColFam, syncedProps, tableDescsToSync); } } }
private static boolean hasInactiveIndex(PMetaData metaCache, PTableKey key) throws TableNotFoundException { PTable table = metaCache.getTableRef(key).getTable(); for (PTable index : table.getIndexes()) { if (index.getIndexState() == PIndexState.INACTIVE) { return true; } } return false; }
private static boolean hasIndexWithState(PMetaData metaCache, PTableKey key, PIndexState expectedState) throws TableNotFoundException { PTable table = metaCache.getTableRef(key).getTable(); for (PTable index : table.getIndexes()) { if (index.getIndexState() == expectedState) { return true; } } return false; }
private void serializeIndexMaintainerIntoScan(Scan scan, PTable dataTable) throws SQLException { PName name = context.getCurrentTable().getTable().getName(); List<PTable> indexes = Lists.newArrayListWithExpectedSize(1); for (PTable index : dataTable.getIndexes()) { if (index.getName().equals(name) && index.getIndexType() == IndexType.LOCAL) { indexes.add(index); break; } } ImmutableBytesWritable ptr = new ImmutableBytesWritable(); IndexMaintainer.serialize(dataTable, ptr, indexes, context.getConnection()); scan.setAttribute(BaseScannerRegionObserver.LOCAL_INDEX_BUILD_PROTO, ByteUtil.copyKeyBytesIfNecessary(ptr)); if (dataTable.isTransactional()) { scan.setAttribute(BaseScannerRegionObserver.TX_STATE, context.getConnection().getMutationState().encodeTransaction()); } }
@Test public void testAsyncIndexRegularBuild() throws Exception { try (Connection conn = DriverManager.getConnection(getUrl())) { conn.setAutoCommit(true); Statement stmt = conn.createStatement(); String tableName = "TBL_" + generateUniqueName(); String indexName = "IND_" + generateUniqueName(); String ddl = "CREATE TABLE " + tableName + " (pk INTEGER NOT NULL PRIMARY KEY, val VARCHAR)"; stmt.execute(ddl); stmt.execute("UPSERT INTO " + tableName + " values(1, 'y')"); // create the async index stmt.execute("CREATE INDEX " + indexName + " ON " + tableName + "(val) ASYNC"); // it should be built as a regular index PhoenixConnection phxConn = conn.unwrap(PhoenixConnection.class); PTable table = phxConn.getTable(new PTableKey(null, tableName)); assertEquals("Index not built", 1, table.getIndexes().size()); assertEquals("Wrong index created", indexName, table.getIndexes().get(0).getName().getString()); ResultSet rs = stmt.executeQuery("select /*+ INDEX(" + indexName + ")*/ pk, val from " + tableName); assertTrue(rs.next()); assertEquals(1, rs.getInt(1)); assertEquals("y", rs.getString(2)); assertFalse(rs.next()); } }
private void flushParentPhysicalTable(PTable table) throws SQLException { byte[] parentPhysicalTableName = null; if (PTableType.VIEW == table.getType()) { if (!table.getIndexes().isEmpty()) { parentPhysicalTableName = table.getPhysicalName().getBytes(); } } else if (PTableType.INDEX == table.getType()) { PTable parentTable = getTable(table.getTenantId(), table.getParentName().getString(), HConstants.LATEST_TIMESTAMP); parentPhysicalTableName = parentTable.getPhysicalName().getBytes(); } if (parentPhysicalTableName != null) { flushTable(parentPhysicalTableName); } }
PTable dataPTable = IndexUtil.getPDataTable(conn, env.getRegion().getTableDescriptor()); final List<IndexMaintainer> maintainers = Lists .newArrayListWithExpectedSize(dataPTable.getIndexes().size()); for (PTable index : dataPTable.getIndexes()) { if (index.getIndexType() == IndexType.LOCAL) { maintainers.add(index.getIndexMaintainer(dataPTable, conn));
PMetaData metaCache = conn1.unwrap(PhoenixConnection.class).getMetaDataCache(); PTable table = metaCache.getTableRef(key).getTable(); for (PTable index : table.getIndexes()) { assertEquals(PIndexState.DISABLE, index.getIndexState());
private static final void dumpStateOfIndexes(Connection conn, String tableName, boolean beforeRebuildTaskRun) throws SQLException { PhoenixConnection phxConn = conn.unwrap(PhoenixConnection.class); PTable table = phxConn.getTable(new PTableKey(phxConn.getTenantId(), tableName)); List<PTable> indexes = table.getIndexes(); String s = beforeRebuildTaskRun ? "before rebuild run" : "after rebuild run"; System.out.println("************Index state in connection " + s + "******************"); for (PTable idx : indexes) { System.out.println( "Index Name: " + idx.getName().getString() + " State: " + idx.getIndexState() + " Disable timestamp: " + idx.getIndexDisableTimestamp()); } System.out.println("************Index state from server " + s + "******************"); table = PhoenixRuntime.getTableNoCache(phxConn, fullTableName); for (PTable idx : table.getIndexes()) { System.out.println( "Index Name: " + idx.getName().getString() + " State: " + idx.getIndexState() + " Disable timestamp: " + idx.getIndexDisableTimestamp()); } }