public static byte[] getChildLinkKey(PName parentTenantId, PName parentSchemaName, PName parentTableName, PName viewTenantId, PName viewName) { return ByteUtil.concat(parentTenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : parentTenantId.getBytes(), QueryConstants.SEPARATOR_BYTE_ARRAY, parentSchemaName == null ? ByteUtil.EMPTY_BYTE_ARRAY : parentSchemaName.getBytes(), QueryConstants.SEPARATOR_BYTE_ARRAY, parentTableName.getBytes(), QueryConstants.SEPARATOR_BYTE_ARRAY, viewTenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : viewTenantId.getBytes(), QueryConstants.SEPARATOR_BYTE_ARRAY, viewName.getBytes()); }
public static void checkTenantId(PName tenantId) { // tenantId should be null or not empty Preconditions.checkArgument(tenantId == null || tenantId.getBytes().length > 0); }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((tenantId == null || tenantId.getBytes().length==0) ? 0 : tenantId.hashCode()); result = prime * result + name.hashCode(); return result; }
@Override public byte[] getColumnQualifierBytes() { // Needed for backward compatibility if (!SchemaUtil.isPKColumn(this) && columnQualifierBytes == null) { return this.name.getBytes(); } return columnQualifierBytes; }
public static byte[] getTenantIdBytes(RowKeySchema schema, boolean isSalted, PName tenantId, boolean isMultiTenantTable, boolean isSharedIndex) throws SQLException { return isMultiTenantTable ? getTenantIdBytes(schema, isSalted, tenantId, isSharedIndex) : tenantId.getBytes(); }
public static byte[] getTableKey(PTable dataTable) { PName tenantId = dataTable.getTenantId(); PName schemaName = dataTable.getSchemaName(); return getTableKey(tenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : tenantId.getBytes(), schemaName == null ? ByteUtil.EMPTY_BYTE_ARRAY : schemaName.getBytes(), dataTable.getTableName().getBytes()); }
@Override public PName getPhysicalName() { if (physicalNames.isEmpty()) { return SchemaUtil.getPhysicalHBaseTableName(schemaName, tableName, isNamespaceMapped); } else { return PNameFactory.newName(physicalNames.get(0).getBytes()); } }
public Builder setFamilyAttributes(List<PColumnFamily> families) { this.familyByBytes = Maps.newHashMapWithExpectedSize(families.size()); this.familyByString = Maps.newHashMapWithExpectedSize(families.size()); for (PColumnFamily family : families) { familyByBytes.put(family.getName().getBytes(), family); familyByString.put(family.getName().getString(), family); } this.families = families; return this; }
private void addIndexToTable(PName tenantId, PName schemaName, PName indexName, PName tableName, long clientTimeStamp, List<PTable> indexes, int clientVersion, boolean skipAddingParentColumns) throws IOException, SQLException { byte[] tenantIdBytes = tenantId == null ? ByteUtil.EMPTY_BYTE_ARRAY : tenantId.getBytes(); PTable indexTable = doGetTable(tenantIdBytes, schemaName.getBytes(), indexName.getBytes(), clientTimeStamp, null, clientVersion, false, skipAddingParentColumns, null); if (indexTable == null) { ServerUtil.throwIOException("Index not found", new TableNotFoundException(schemaName.getString(), indexName.getString())); return; } indexes.add(indexTable); }
public KeyValueColumnExpression(PColumn column, String displayName) { super(column); this.cf = column.getFamilyName().getBytes(); // for backward compatibility since older tables won't have columnQualifierBytes in their metadata this.cq = column.getColumnQualifierBytes() != null ? column.getColumnQualifierBytes() : column.getName().getBytes(); this.displayName = displayName; }
public SingleCellColumnExpression(PColumn column, String displayName, QualifierEncodingScheme encodingScheme, ImmutableStorageScheme immutableStorageScheme) { super(column, column.getFamilyName().getBytes(), SINGLE_KEYVALUE_COLUMN_QUALIFIER_BYTES); this.immutableStorageScheme = immutableStorageScheme; Preconditions.checkNotNull(encodingScheme); Preconditions.checkArgument(encodingScheme != NON_ENCODED_QUALIFIERS); this.arrayColDisplayName = displayName; this.decodedColumnQualifier = encodingScheme.decode(column.getColumnQualifierBytes()); this.encodingScheme = encodingScheme; setKeyValueExpression(); }
private static void projectAllColumnFamilies(PTable table, Scan scan) { // Will project all known/declared column families scan.getFamilyMap().clear(); for (PColumnFamily family : table.getColumnFamilies()) { scan.addFamily(family.getName().getBytes()); } }
public KeyValueColumnExpression(PColumn column) { super(column); this.cf = column.getFamilyName().getBytes(); // for backward compatibility since older tables won't have columnQualifierBytes in their metadata this.cq = column.getColumnQualifierBytes() != null ? column.getColumnQualifierBytes() : column.getName().getBytes(); this.displayName = column.getName().getString(); }
@Override public PName getParentSchemaName() { // a view on a table will not have a parent name but will have a physical table name (which is the parent) return (type!=PTableType.VIEW || parentName!=null) ? parentSchemaName : PNameFactory.newName(SchemaUtil.getSchemaNameFromFullName(getPhysicalName().getBytes())); }
@Override public PName getParentTableName() { // a view on a table will not have a parent name but will have a physical table name (which is the parent) return (type!=PTableType.VIEW || parentName!=null) ? parentTableName : PNameFactory.newName(SchemaUtil.getTableNameFromFullName(getPhysicalName().getBytes())); }
public void invalidateAll(PTable table) { byte[] physicalName = table.getPhysicalName().getBytes(); List<PColumnFamily> families = table.getColumnFamilies(); if (families.isEmpty()) { invalidate(new GuidePostsKey(physicalName, SchemaUtil.getEmptyColumnFamily(table))); } else { for (PColumnFamily family : families) { invalidate(new GuidePostsKey(physicalName, family.getName().getBytes())); } } }
public ServerCache createServerCache(byte[] cacheId, QueryPlan delegate) throws SQLException, IOException { PTable cacheUsingTable = delegate.getTableRef().getTable(); ConnectionQueryServices services = delegate.getContext().getConnection().getQueryServices(); List<HRegionLocation> locations = services.getAllTableRegions( cacheUsingTable.getPhysicalName().getBytes()); int nRegions = locations.size(); Set<HRegionLocation> servers = new HashSet<>(nRegions); cacheUsingTableMap.put(Bytes.mapKey(cacheId), cacheUsingTable); return new ServerCache(cacheId, servers, new ImmutableBytesWritable( new byte[]{}), services, false); }
public Table getHTable(PTable table) throws SQLException { Table htable = this.getConnection().getQueryServices().getTable(table.getPhysicalName().getBytes()); if (table.isTransactional() && phoenixTransactionContext.isTransactionRunning()) { // We're only using this table for reading, so we want it wrapped even if it's an index htable = phoenixTransactionContext.getTransactionalTable(htable, table.isImmutableRows() || table.getType() == PTableType.INDEX); } return htable; }
private static void invalidateStats(Connection conn, String tableName) throws SQLException { PTable ptable = conn.unwrap(PhoenixConnection.class) .getMetaDataCache().getTableRef(new PTableKey(null, tableName)) .getTable(); byte[] name = ptable.getPhysicalName().getBytes(); conn.unwrap(PhoenixConnection.class).getQueryServices().invalidateStats(new GuidePostsKey(name, SchemaUtil.getEmptyColumnFamily(ptable))); }