@Override public Multimap<Cell, Long> getAllTimestamps(final TableReference tableRef, final Set<Cell> cells, final long timestamp) throws InsufficientConsistencyException { if (cells.isEmpty()) { return ImmutableMultimap.of(); } Multimap<Cell, Long> toReturn = ArrayListMultimap.create(); for (List<Cell> partition : Iterables.partition(cells, batchSizeForReads)) { toReturn.putAll(run(ctx -> { Result<? extends Record> records = ctx .select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(values(ctx, toRows(Sets.newHashSet(partition)), TEMP_TABLE_1, ROW_NAME, COL_NAME)) .on(A_ROW_NAME.eq(T1_ROW_NAME) .and(A_COL_NAME.eq(T1_COL_NAME))) .where(A_TIMESTAMP.lessThan(timestamp)) .fetch(); Multimap<Cell, Long> results = ArrayListMultimap.create(records.size() / 4, 4); for (Record record : records) { results.put( Cell.create(record.getValue(A_ROW_NAME), record.getValue(A_COL_NAME)), record.getValue(A_TIMESTAMP)); } return results; })); } return toReturn; }
private Result<? extends Record> fetchValues(DSLContext ctx, TableReference tableRef, Select<? extends Record> subQuery) { return ctx.select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP, A_VALUE) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(subQuery.asTable(TEMP_TABLE_2)) .on(A_ROW_NAME.eq(T2_ROW_NAME) .and(A_COL_NAME.eq(T2_COL_NAME)) .and(A_TIMESTAMP.eq(T2_MAX_TIMESTAMP))) .fetch(); }
private Select<? extends Record> getLatestTimestampQueryManyTimestamps(DSLContext ctx, TableReference tableRef, RowN[] rows) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(values(ctx, rows, TEMP_TABLE_1, ROW_NAME, COL_NAME, TIMESTAMP)) .on(A_ROW_NAME.eq(T1_ROW_NAME) .and(A_COL_NAME.eq(T1_COL_NAME))) .where(A_TIMESTAMP.lessThan(T1_TIMESTAMP)) .groupBy(A_ROW_NAME, A_COL_NAME); }
@Override public Agent getHostAgentForDelegate(long agentId) { List<? extends Agent> result = create().select(AGENT.fields()) .from(AGENT) .join(HOST) .on(HOST.AGENT_ID.eq(AGENT.ID)) .join(INSTANCE_HOST_MAP) .on(INSTANCE_HOST_MAP.HOST_ID.eq(HOST.ID)) .join(INSTANCE) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .where(INSTANCE.AGENT_ID.eq(agentId)).fetchInto(AgentRecord.class); return result.size() == 0 ? null : result.get(0); }
@Override public Map<String, List<InstanceHostMap>> getInstanceHostMapsWithHostUuid(long instanceId) { Map<Record, List<InstanceHostMap>> result = create() .select(INSTANCE_HOST_MAP.fields()).select(HOST.UUID) .from(INSTANCE_HOST_MAP) .join(HOST).on(INSTANCE_HOST_MAP.HOST_ID.eq(HOST.ID)) .where(INSTANCE_HOST_MAP.INSTANCE_ID.eq(instanceId) .and(INSTANCE_HOST_MAP.REMOVED.isNull())) .fetchGroups(new Field[]{HOST.UUID}, InstanceHostMap.class); Map<String, List<InstanceHostMap>> maps = new HashMap<>(); for (Map.Entry<Record, List<InstanceHostMap>>entry : result.entrySet()) { String uuid = (String)entry.getKey().getValue(0); maps.put(uuid, entry.getValue()); } return maps; }
@Override public Host getHostForInstance(long instanceId) { List<? extends Host> results = create() .select(HOST.fields()) .from(HOST) .join(INSTANCE_HOST_MAP) .on(HOST.ID.eq(INSTANCE_HOST_MAP.HOST_ID)) .where(INSTANCE_HOST_MAP.INSTANCE_ID.eq(instanceId)) .fetchInto(HostRecord.class); if (results.size() > 0) { return results.get(0); } return null; }
@Override public List<? extends Host> getHosts(Collection<? extends StoragePool> pools) { if (pools == null || pools.isEmpty()) { return new ArrayList<>(); } Collection<Long> poolIds = new HashSet<>(); for (StoragePool p : pools) { poolIds.add(p.getId()); } return create() .select(HOST.fields()) .from(HOST) .join(STORAGE_POOL_HOST_MAP) .on(STORAGE_POOL_HOST_MAP.HOST_ID.eq(HOST.ID)) .where(STORAGE_POOL_HOST_MAP.REMOVED.isNull() .and(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID.in(poolIds))) .fetchInto(HostRecord.class); }
protected List<? extends ExternalHandlerData> getExternalHandlerDataInternal(String processName) { List<Field<?>> fields = new ArrayList<Field<?>>(Arrays.asList(EXTERNAL_HANDLER.fields())); fields.add(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP.ON_ERROR); fields.add(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP.EVENT_NAME); return create() .select(fields) .from(EXTERNAL_HANDLER) .join(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP) .on(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP.EXTERNAL_HANDLER_ID.eq(EXTERNAL_HANDLER.ID)) .join(EXTERNAL_HANDLER_PROCESS) .on(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP.EXTERNAL_HANDLER_PROCESS_ID.eq(EXTERNAL_HANDLER_PROCESS.ID)) .where( EXTERNAL_HANDLER_PROCESS.NAME.eq(processName) .and(EXTERNAL_HANDLER.STATE.eq(CommonStatesConstants.ACTIVE)) .and(EXTERNAL_HANDLER_EXTERNAL_HANDLER_PROCESS_MAP.STATE.eq(CommonStatesConstants.ACTIVE)) .and(EXTERNAL_HANDLER_PROCESS.STATE.eq(CommonStatesConstants.ACTIVE))) .fetchInto(ExternalHandlerData.class); }
@Override public Long getAgentIdForInstanceHostMap(String instanceHostMap) { if ( instanceHostMap == null ) { return null; } return create() .select(HOST.AGENT_ID) .from(HOST) .join(INSTANCE_HOST_MAP) .on(INSTANCE_HOST_MAP.HOST_ID.eq(HOST.ID)) .where(INSTANCE_HOST_MAP.ID.eq(Long.parseLong(instanceHostMap))) .fetchOne(HOST.AGENT_ID); }
@Override public Map<Long, PhysicalHost> getPhysicalHostsForHosts(List<Long> hostIds) { Map<Long, PhysicalHost> hosts = new HashMap<>(); List<? extends PhysicalHost> hostList = create().select(PHYSICAL_HOST.fields()) .from(PHYSICAL_HOST) .join(HOST) .on(HOST.PHYSICAL_HOST_ID.eq(PHYSICAL_HOST.ID)) .where(HOST.ID.in(hostIds)) .fetchInto(PhysicalHostRecord.class); for (PhysicalHost host : hostList) { hosts.put(host.getId(), host); } return hosts; }
@Override public List<Long> findVolumesInUseByServiceDriver(Long serviceId) { return create().select(VOLUME.ID) .from(VOLUME) .join(VOLUME_STORAGE_POOL_MAP) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID)) .join(STORAGE_POOL) .on(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID)) .join(STORAGE_DRIVER) .on(STORAGE_DRIVER.ID.eq(STORAGE_POOL.STORAGE_DRIVER_ID)) .where(STORAGE_DRIVER.REMOVED.isNull() .and(STORAGE_DRIVER.SERVICE_ID.eq(serviceId)) .and(VOLUME.REMOVED.isNull())) .fetch().into(Long.class); }
@Override public List<? extends Volume> findNonRemovedVolumesOnPool(Long storagePoolId) { return create().select(VOLUME.fields()) .from(VOLUME) .join(VOLUME_STORAGE_POOL_MAP) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID)) .join(STORAGE_POOL) .on(STORAGE_POOL.ID.eq(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID)) .where(VOLUME.REMOVED.isNull() .and(STORAGE_POOL.REMOVED.isNotNull())) .fetchInto(VolumeRecord.class); }
@Override public Host getHostForIpAddress(long ipAddressId) { List<? extends Host> hosts = create() .select(HOST.fields()) .from(HOST) .join(HOST_IP_ADDRESS_MAP) .on(HOST_IP_ADDRESS_MAP.HOST_ID.eq(HOST.ID)) .where(HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID.eq(ipAddressId) .and(HOST_IP_ADDRESS_MAP.REMOVED.isNull())) .fetchInto(HostRecord.class); if (hosts.isEmpty()) { return null; } return hosts.get(0); }
@Override public boolean isInstanceImageKind(long instanceId, String kind) { return create().select(STORAGE_POOL.fields()) .from(STORAGE_POOL) .join(IMAGE_STORAGE_POOL_MAP) .on(STORAGE_POOL.ID.eq(IMAGE_STORAGE_POOL_MAP.STORAGE_POOL_ID)) .join(IMAGE) .on(IMAGE.ID.eq(IMAGE_STORAGE_POOL_MAP.IMAGE_ID)) .join(INSTANCE) .on(INSTANCE.IMAGE_ID.eq(IMAGE.ID)) .where( INSTANCE.ID.eq(instanceId) .and(IMAGE_STORAGE_POOL_MAP.REMOVED.isNull()) .and(STORAGE_POOL.KIND.eq(kind))) .fetch().size() > 0; }
@Override public IpAddress getIpAddressForHost(Long hostId) { List<? extends IpAddress> result = create() .select(IP_ADDRESS.fields()) .from(IP_ADDRESS) .join(HOST_IP_ADDRESS_MAP) .on(IP_ADDRESS.ID.eq(HOST_IP_ADDRESS_MAP.IP_ADDRESS_ID)) .where(HOST_IP_ADDRESS_MAP.HOST_ID.eq(hostId) .and(HOST_IP_ADDRESS_MAP.REMOVED.isNull()) .and(IP_ADDRESS.REMOVED.isNull())) .fetchInto(IpAddressRecord.class); return result.size() == 0 ? null : result.get(0); }
@Override public List<? extends Host> findHosts(long accountId, long instanceId) { return create().select(HOST.fields()) .from(INSTANCE) .join(INSTANCE_HOST_MAP) .on(INSTANCE.ID.eq(INSTANCE_HOST_MAP.INSTANCE_ID)) .join(HOST) .on(HOST.ID.eq(INSTANCE_HOST_MAP.HOST_ID)) .where(HOST.REMOVED.isNull() .and(INSTANCE_HOST_MAP.REMOVED.isNull()) .and(INSTANCE.ID.eq(instanceId))) .fetchInto(HostRecord.class); }
private List<String> enumLabels(String nspname, String typname, Field<?> orderBy) { return create().select(PG_ENUM.ENUMLABEL) .from(PG_ENUM) .join(PG_TYPE).on(PG_ENUM.ENUMTYPID.eq(oid(PG_TYPE))) .join(PG_NAMESPACE).on(PG_TYPE.TYPNAMESPACE.eq(oid(PG_NAMESPACE))) .where(PG_NAMESPACE.NSPNAME.eq(nspname)) .and(PG_TYPE.TYPNAME.eq(typname)) .orderBy(orderBy) .fetch(PG_ENUM.ENUMLABEL); } }
@Override public List<? extends Instance> findBadInstances(int count) { return create().select(INSTANCE.fields()) .from(INSTANCE) .join(INSTANCE_HOST_MAP) .on(INSTANCE_HOST_MAP.INSTANCE_ID.eq(INSTANCE.ID)) .join(HOST) .on(INSTANCE_HOST_MAP.HOST_ID.eq(HOST.ID)) .where(HOST.REMOVED.isNotNull().and(INSTANCE.REMOVED.isNull()) .and(INSTANCE.STATE.notIn(InstanceConstants.STATE_STOPPING, CommonStatesConstants.REMOVING))) .limit(count) .fetchInto(InstanceRecord.class); }
@Override public List<? extends StoragePoolHostMap> findBadPoolMapss(int limit) { return create().select(STORAGE_POOL_HOST_MAP.fields()) .from(STORAGE_POOL_HOST_MAP) .join(STORAGE_POOL) .on(STORAGE_POOL.ID.eq(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID)) .join(HOST) .on(HOST.ID.eq(STORAGE_POOL_HOST_MAP.HOST_ID)) .where(STORAGE_POOL_HOST_MAP.REMOVED.isNull() .and(HOST.STATE.eq(CommonStatesConstants.PURGED).or(STORAGE_POOL.STATE.eq(CommonStatesConstants.PURGED)))) .limit(limit) .fetchInto(StoragePoolHostMapRecord.class); }
@Override public List<? extends Volume> findBadNativeVolumes(int count) { return create().select(VOLUME.fields()) .from(VOLUME) .join(MOUNT) .on(MOUNT.VOLUME_ID.eq(VOLUME.ID)) .join(INSTANCE) .on(MOUNT.INSTANCE_ID.eq(INSTANCE.ID)) .where(INSTANCE.STATE.eq(CommonStatesConstants.PURGED) .and(VOLUME.STATE.eq(CommonStatesConstants.INACTIVE)) .and(INSTANCE.NATIVE_CONTAINER.isTrue())) .limit(count) .fetchInto(VolumeRecord.class); }