@Override public PName getName() { return delegate.getName(); }
private static boolean isTableDeleted(PTable table) { return table.getName() == null; }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; TableRef other = (TableRef)obj; if (!Objects.equals(alias, other.alias)) return false; if (!Objects.equals(table.getName(), other.table.getName())) return false; return true; }
public static boolean isSequenceTable(PTable table) { return PhoenixDatabaseMetaData.SYSTEM_SEQUENCE_NAME.equals(table.getName().getString()); }
public static boolean isTaskTable(PTable table) { return PhoenixDatabaseMetaData.SYSTEM_TASK_NAME.equals(table.getName().getString()); }
private static boolean isInvalidTableToUpgrade(PTable table) throws SQLException { return (table.getType() != PTableType.TABLE || // Must be a table table.getTenantId() != null || // Must be global !table.getPhysicalName().equals(table.getName())); // Must be the physical table } /**
@Override public Void visit(NamedTableNode tableNode) throws SQLException { String alias = tableNode.getAlias(); TableRef tableRef = createTableRef(connectionSchemaName, tableNode, true, false); PTable theTable = tableRef.getTable(); if (alias != null) { tableMap.put(alias, tableRef); } String name = theTable.getName().getString(); //avoid having one name mapped to two identical TableRef. if (alias == null || !alias.equals(name)) { tableMap.put(name, tableRef); } tables.add(tableRef); return null; }
/** * 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; }
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()); } }
public ColumnRef(TableRef tableRef, int columnPosition) { if (tableRef == null) { throw new NullPointerException(); } if (columnPosition < 0 || columnPosition >= tableRef.getTable().getColumns().size()) { throw new IllegalArgumentException("Column position of " + columnPosition + " must be between 0 and " + tableRef.getTable().getColumns().size() + " for table " + tableRef.getTable().getName().getString()); } this.tableRef = tableRef; this.columnPosition = columnPosition; PColumn column = getColumn(); int i = -1; if (SchemaUtil.isPKColumn(column)) { for (PColumn pkColumn : tableRef.getTable().getPKColumns()) { i++; if (pkColumn == column) { break; } } } pkSlotPosition = i; }
@Override public ExplainPlan getExplainPlan() throws SQLException { if (context.getScanRanges() == ScanRanges.NOTHING) { return new ExplainPlan(Collections.singletonList("DEGENERATE SCAN OVER " + getTableRef().getTable().getName().getString())); } ResultIterator iterator = iterator(); ExplainPlan explainPlan = new ExplainPlan(getPlanSteps(iterator)); iterator.close(); return explainPlan; }
@Override public void markDMLFence(PTable table) { if (table.getType() == PTableType.INDEX) { return; } byte[] logicalKey = table.getName().getBytes(); TransactionAware logicalTxAware = VisibilityFence.create(logicalKey); if (this.txContext == null) { this.txAwares.add(logicalTxAware); } else { this.txContext.addTransactionAware(logicalTxAware); } byte[] physicalKey = table.getPhysicalName().getBytes(); if (Bytes.compareTo(physicalKey, logicalKey) != 0) { TransactionAware physicalTxAware = VisibilityFence .create(physicalKey); if (this.txContext == null) { this.txAwares.add(physicalTxAware); } else { this.txContext.addTransactionAware(physicalTxAware); } } }
@Override public void addTable(PTable table, long resolvedTime) throws SQLException { synchronized (latestMetaDataLock) { try { throwConnectionClosedIfNullMetaData(); // If existing table isn't older than new table, don't replace // If a client opens a connection at an earlier timestamp, this can happen PTable existingTable = latestMetaData.getTableRef(new PTableKey(table.getTenantId(), table.getName().getString())).getTable(); if (existingTable.getTimeStamp() >= table.getTimeStamp()) { return; } } catch (TableNotFoundException e) {} latestMetaData.addTable(table, resolvedTime); latestMetaDataLock.notifyAll(); } } @Override
@Override public void commitDDLFence(PTable dataTable) throws SQLException { try { tx = (HBaseTransaction) tm.fence(dataTable.getName().getBytes()); if (logger.isInfoEnabled()) { logger.info("Added write fence at ~" + tx.getReadTimestamp()); } } catch (TransactionException e) { throw new SQLExceptionInfo.Builder( SQLExceptionCode.TX_UNABLE_TO_GET_WRITE_FENCE) .setSchemaName(dataTable.getSchemaName().getString()) .setTableName(dataTable.getTableName().getString()).build() .buildException(); } }
public void assertViewType(String[] viewNames, String[] viewDDLs, ViewType viewType) throws Exception { Properties props = PropertiesUtil.deepCopy(TEST_PROPERTIES); PhoenixConnection conn = DriverManager.getConnection(getUrl(), props).unwrap(PhoenixConnection.class); String ct = "CREATE TABLE t (k1 INTEGER NOT NULL, k2 VARCHAR, v VARCHAR, CONSTRAINT pk PRIMARY KEY (k1,k2))"; conn.createStatement().execute(ct); for (String viewDDL : viewDDLs) { conn.createStatement().execute(viewDDL); } StringBuilder buf = new StringBuilder(); int count = 0; for (String view : viewNames) { PTable table = conn.getTable(new PTableKey(null, view)); assertEquals(viewType, table.getViewType()); conn.createStatement().execute("DROP VIEW " + table.getName().getString()); buf.append(' '); buf.append(table.getName().getString()); count++; } assertEquals("Expected " + viewDDLs.length + ", but got " + count + ":"+ buf.toString(), viewDDLs.length, count); }
private static void projectTableColumnFamily(StatementContext context, String cfName, TableRef tableRef, boolean resolveColumn, List<Expression> projectedExpressions, List<ExpressionProjector> projectedColumns) throws SQLException { PTable table = tableRef.getTable(); PColumnFamily pfamily = table.getColumnFamily(cfName); for (PColumn column : pfamily.getColumns()) { ColumnRef ref = new ColumnRef(tableRef, column.getPosition()); if (resolveColumn) { ref = context.getResolver().resolveColumn(table.getTableName().getString(), cfName, column.getName().getString()); } Expression expression = ref.newColumnExpression(); projectedExpressions.add(expression); String colName = column.getName().toString(); boolean isCaseSensitive = !SchemaUtil.normalizeIdentifier(colName).equals(colName); projectedColumns.add(new ExpressionProjector(colName, tableRef.getTableAlias() == null ? table.getName().getString() : tableRef.getTableAlias(), expression, isCaseSensitive)); } }
private void testHintForIndexOnView(boolean includeColumns) throws Exception { Properties props = new Properties(); Connection conn1 = DriverManager.getConnection(getUrl(), props); conn1.setAutoCommit(true); String tableName = SchemaUtil.getTableName(SCHEMA1, generateUniqueName()); String viewName = SchemaUtil.getTableName(SCHEMA2, generateUniqueName()); String indexName = generateUniqueName(); String fullIndexName = SchemaUtil.getTableName(SCHEMA2, indexName); conn1.createStatement().execute( "CREATE TABLE "+tableName+" (k VARCHAR PRIMARY KEY, v1 VARCHAR, v2 VARCHAR) UPDATE_CACHE_FREQUENCY=1000000"); conn1.createStatement().execute("upsert into "+tableName+" values ('row1', 'value1', 'key1')"); conn1.createStatement().execute( "CREATE VIEW "+viewName+" (v3 VARCHAR, v4 VARCHAR) AS SELECT * FROM "+tableName+" WHERE v1 = 'value1'"); conn1.createStatement().execute("CREATE INDEX " + indexName + " ON " + viewName + "(v3)" + (includeColumns ? " INCLUDE(v4)" : "")); PhoenixStatement stmt = conn1.createStatement().unwrap(PhoenixStatement.class); ResultSet rs = stmt.executeQuery("SELECT /*+ INDEX(" + viewName + " " + fullIndexName + ") */ v1 FROM " + viewName + " WHERE v3 = 'foo' ORDER BY v4"); assertFalse(rs.next()); assertEquals(fullIndexName, stmt.getQueryPlan().getContext().getCurrentTable().getTable().getName().getString()); }
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()); } }
private void assertRowCount(Connection conn, String fullTableName, String fullBaseName, int expectedCount) throws SQLException { PhoenixStatement stmt = conn.createStatement().unwrap(PhoenixStatement.class); ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM " + fullTableName); assertTrue(rs.next()); assertEquals(expectedCount, rs.getInt(1)); // Ensure that index is being used rs = stmt.executeQuery("EXPLAIN SELECT COUNT(*) FROM " + fullTableName); if (fullBaseName != null) { // Uses index and finds correct number of rows assertTrue(QueryUtil.getExplainPlan(rs).startsWith("CLIENT PARALLEL 1-WAY RANGE SCAN OVER " + Bytes.toString(MetaDataUtil.getViewIndexPhysicalName(Bytes.toBytes(fullBaseName))))); } // Force it not to use index and still finds correct number of rows rs = stmt.executeQuery("SELECT /*+ NO_INDEX */ * FROM " + fullTableName); int count = 0; while (rs.next()) { count++; } assertEquals(expectedCount, count); // Ensure that the table, not index is being used assertEquals(fullTableName, stmt.getQueryPlan().getContext().getCurrentTable().getTable().getName().getString()); }