@Override public List<? extends Instance> getInstancesWithHealtcheckEnabled(long accountId) { return create().select(INSTANCE.fields()) .from(INSTANCE) .join(HEALTHCHECK_INSTANCE) .on(HEALTHCHECK_INSTANCE.INSTANCE_ID.eq(INSTANCE.ID)) .and(HEALTHCHECK_INSTANCE.REMOVED.isNull()) .and(INSTANCE.REMOVED.isNull()) .and(INSTANCE.STATE.in(InstanceConstants.STATE_STARTING, InstanceConstants.STATE_RUNNING) .and(INSTANCE.ACCOUNT_ID.eq(accountId))) .fetchInto(InstanceRecord.class); }
@Override public List<String> getSpanNames(String serviceName) { if (serviceName == null) return emptyList(); serviceName = serviceName.toLowerCase(); // service names are always lowercase! try (Connection conn = datasource.getConnection()) { return context.get(conn) .selectDistinct(ZIPKIN_SPANS.NAME) .from(ZIPKIN_SPANS) .join(ZIPKIN_ANNOTATIONS) .on(ZIPKIN_SPANS.TRACE_ID.eq(ZIPKIN_ANNOTATIONS.TRACE_ID)) .and(ZIPKIN_SPANS.ID.eq(ZIPKIN_ANNOTATIONS.SPAN_ID)) .where(ZIPKIN_ANNOTATIONS.ENDPOINT_SERVICE_NAME.eq(serviceName)) .orderBy(ZIPKIN_SPANS.NAME) .fetch(ZIPKIN_SPANS.NAME); } catch (SQLException e) { throw new RuntimeException("Error querying for " + serviceName + ": " + e.getMessage()); } }
@Override public List<String> getSpanNames(String serviceName) { if (serviceName == null) return emptyList(); serviceName = serviceName.toLowerCase(); // service names are always lowercase! try (Connection conn = datasource.getConnection()) { return context(conn) .selectDistinct(ZIPKIN_SPANS.NAME) .from(ZIPKIN_SPANS) .join(ZIPKIN_ANNOTATIONS) .on(ZIPKIN_SPANS.TRACE_ID.eq(ZIPKIN_ANNOTATIONS.TRACE_ID)) .and(ZIPKIN_SPANS.ID.eq(ZIPKIN_ANNOTATIONS.SPAN_ID)) .where(ZIPKIN_ANNOTATIONS.ENDPOINT_SERVICE_NAME.eq(serviceName)) .orderBy(ZIPKIN_SPANS.NAME) .fetch(ZIPKIN_SPANS.NAME); } catch (SQLException e) { throw new RuntimeException("Error querying for " + serviceName + ": " + e.getMessage()); } }
@Override public List<String> getSpanNames(String serviceName) { if (serviceName == null) return emptyList(); serviceName = serviceName.toLowerCase(); // service names are always lowercase! try (Connection conn = datasource.getConnection()) { return context.get(conn) .selectDistinct(ZIPKIN_SPANS.NAME) .from(ZIPKIN_SPANS) .join(ZIPKIN_ANNOTATIONS) .on(ZIPKIN_SPANS.TRACE_ID.eq(ZIPKIN_ANNOTATIONS.TRACE_ID)) .and(ZIPKIN_SPANS.ID.eq(ZIPKIN_ANNOTATIONS.SPAN_ID)) .where(ZIPKIN_ANNOTATIONS.ENDPOINT_SERVICE_NAME.eq(serviceName)) .orderBy(ZIPKIN_SPANS.NAME) .fetch(ZIPKIN_SPANS.NAME); } catch (SQLException e) { throw new RuntimeException("Error querying for " + serviceName + ": " + e.getMessage()); } }
private Result<Record4<String, String, String, String>> fetchKeys(String... constraintTypes) { return create().select( Constraints.TABLE_SCHEMA, Constraints.TABLE_NAME, Constraints.CONSTRAINT_NAME, Indexes.COLUMN_NAME) .from(CONSTRAINTS) .join(INDEXES) .on(Constraints.TABLE_SCHEMA.eq(Indexes.TABLE_SCHEMA)) .and(Constraints.TABLE_NAME.eq(Indexes.TABLE_NAME)) .and(Constraints.UNIQUE_INDEX_NAME.eq(Indexes.INDEX_NAME)) .where(Constraints.TABLE_SCHEMA.in(getInputSchemata())) .and(Constraints.CONSTRAINT_TYPE.in(constraintTypes)) .orderBy( Constraints.TABLE_SCHEMA, Constraints.CONSTRAINT_NAME, Indexes.ORDINAL_POSITION) .fetch(); }
.join(select.asTable().as(distinctAlias)) .on(recordTypeIdField.eq(DSL.field(DSL.name(distinctAlias, recordTypeIdField.getName()), uuidType))) .and(recordIdField.eq(DSL.field(DSL.name(distinctAlias, recordIdField.getName()), uuidType)));
@Override public void createVolumeInStoragePool(Map<String, Object> volumeData, String volumeName, StoragePool storagePool) { Record record = create() .select(VOLUME.fields()) .from(VOLUME) .join(VOLUME_STORAGE_POOL_MAP) .on(VOLUME_STORAGE_POOL_MAP.VOLUME_ID.eq(VOLUME.ID) .and(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(storagePool.getId()))) .join(STORAGE_POOL) .on(VOLUME_STORAGE_POOL_MAP.STORAGE_POOL_ID.eq(STORAGE_POOL.ID)) .and(STORAGE_POOL.REMOVED.isNull()) .where(VOLUME.NAME.eq(volumeName) .and((VOLUME.REMOVED.isNull().or(VOLUME.STATE.eq(CommonStatesConstants.REMOVING))))) .and(VOLUME.ACCOUNT_ID.eq(storagePool.getAccountId())) .fetchAny(); if (record != null) { return; } Volume volume = resourceDao.createAndSchedule(Volume.class, volumeData); Map<String, Object> vspm = new HashMap<String, Object>(); vspm.put("volumeId", volume.getId()); vspm.put("storagePoolId", storagePool.getId()); resourceDao.createAndSchedule(VolumeStoragePoolMap.class, vspm); }
.and(TypeInfo.POS.equal(0)) .where(FunctionAliases.ALIAS_SCHEMA.in(getInputSchemata())) .and(FunctionAliases.RETURNS_RESULT.in((short) 1, (short) 2))
@Override public Integer getCurrentScale(long serviceId) { return create() .select(DSL.count()) .from(INSTANCE) .join(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID) .and(SERVICE_EXPOSE_MAP.SERVICE_ID.eq(serviceId)) .and(SERVICE_EXPOSE_MAP.STATE.in(CommonStatesConstants.ACTIVATING, CommonStatesConstants.ACTIVE, CommonStatesConstants.REQUESTED)) .and(SERVICE_EXPOSE_MAP.UPGRADE.eq(false)) .and(INSTANCE.STATE.notIn(CommonStatesConstants.PURGING, CommonStatesConstants.PURGED, CommonStatesConstants.REMOVED, CommonStatesConstants.REMOVING, InstanceConstants.STATE_ERROR, InstanceConstants.STATE_ERRORING))) .and(SERVICE_EXPOSE_MAP.DNS_PREFIX.isNull()) .fetchOne(0, Integer.class); }
.join(ROUTINES) .on(PARAMETERS.SPECIFIC_SCHEMA.equal(ROUTINES.SPECIFIC_SCHEMA)) .and(PARAMETERS.SPECIFIC_NAME.equal(ROUTINES.SPECIFIC_NAME)) .leftOuterJoin(ELEMENT_TYPES) .on(ROUTINES.ROUTINE_SCHEMA.equal(ELEMENT_TYPES.OBJECT_SCHEMA)) .and(ROUTINES.ROUTINE_NAME.equal(ELEMENT_TYPES.OBJECT_NAME)) .and(PARAMETERS.DTD_IDENTIFIER.equal(ELEMENT_TYPES.COLLECTION_TYPE_IDENTIFIER)) .where(PARAMETERS.SPECIFIC_SCHEMA.equal(getSchema().getName())) .and(PARAMETERS.SPECIFIC_NAME.equal(this.specificName))
.join(PG_CLASS) .on(PG_CLASS.RELNAME.eq(COLUMNS.TABLE_NAME)) .and(PG_CLASS.RELNAMESPACE.eq(oid(PG_NAMESPACE))) .join(PG_ATTRIBUTE) .on(PG_ATTRIBUTE.ATTRELID.eq(oid(PG_CLASS))) .and(PG_ATTRIBUTE.ATTNAME.eq(COLUMNS.COLUMN_NAME)) .leftOuterJoin(PG_DESCRIPTION) .on(PG_DESCRIPTION.OBJOID.eq(oid(PG_CLASS))) .and(PG_DESCRIPTION.OBJSUBID.eq(COLUMNS.ORDINAL_POSITION)) .where(COLUMNS.TABLE_SCHEMA.equal(getSchema().getName())) .and(COLUMNS.TABLE_NAME.equal(getName()))
private Result<Record4<String, String, String, String>> fetchKeys(String constraintType) { return create() .select( KEY_COLUMN_USAGE.CONSTRAINT_NAME, KEY_COLUMN_USAGE.TABLE_SCHEMA, KEY_COLUMN_USAGE.TABLE_NAME, KEY_COLUMN_USAGE.COLUMN_NAME) .from(TABLE_CONSTRAINTS) .join(KEY_COLUMN_USAGE) .on(TABLE_CONSTRAINTS.CONSTRAINT_SCHEMA.equal(KEY_COLUMN_USAGE.CONSTRAINT_SCHEMA)) .and(TABLE_CONSTRAINTS.CONSTRAINT_NAME.equal(KEY_COLUMN_USAGE.CONSTRAINT_NAME)) .where(TABLE_CONSTRAINTS.CONSTRAINT_TYPE.equal(constraintType)) .and(TABLE_CONSTRAINTS.TABLE_SCHEMA.in(getInputSchemata())) .orderBy( KEY_COLUMN_USAGE.TABLE_SCHEMA.asc(), KEY_COLUMN_USAGE.TABLE_NAME.asc(), KEY_COLUMN_USAGE.CONSTRAINT_NAME.asc(), KEY_COLUMN_USAGE.ORDINAL_POSITION.asc()) .fetch(); }
.leftOuterJoin(ELEMENT_TYPES) .on(COLUMNS.TABLE_SCHEMA.equal(ELEMENT_TYPES.OBJECT_SCHEMA)) .and(COLUMNS.TABLE_NAME.equal(ELEMENT_TYPES.OBJECT_NAME)) .and(COLUMNS.DTD_IDENTIFIER.equal(ELEMENT_TYPES.COLLECTION_TYPE_IDENTIFIER)) .where(COLUMNS.TABLE_SCHEMA.equal(getSchema().getName())) .and(COLUMNS.TABLE_NAME.equal(getName()))
private Result<Record5<String, String, String, String, String>> fetchKeys(String constraintType) { return create().select( Sysschemas.SCHEMANAME, Systables.TABLENAME, Systables.TABLEID, Sysconstraints.CONSTRAINTNAME, Sysconglomerates.DESCRIPTOR) .from(SYSCONGLOMERATES) .join(SYSKEYS) .on(Syskeys.CONGLOMERATEID.equal(Sysconglomerates.CONGLOMERATEID)) .join(SYSCONSTRAINTS) .on(Sysconstraints.CONSTRAINTID.equal(Syskeys.CONSTRAINTID)) .join(SYSTABLES) .on(Systables.TABLEID.equal(Sysconglomerates.TABLEID)) .join(SYSSCHEMAS) .on(Sysschemas.SCHEMAID.equal(Systables.SCHEMAID)) // [#6797] The casts are necessary if a non-standard collation is used .and(Sysschemas.SCHEMANAME.cast(VARCHAR(32672)).in(getInputSchemata())) .where(Sysconstraints.TYPE.cast(VARCHAR(32672)).equal(constraintType)) .orderBy( Sysschemas.SCHEMANAME, Systables.TABLENAME, Sysconstraints.CONSTRAINTNAME) .fetch(); }
.join(KEY_COLUMN_USAGE) .on(ReferentialConstraints.CONSTRAINT_SCHEMA.equal(KeyColumnUsage.CONSTRAINT_SCHEMA)) .and(ReferentialConstraints.CONSTRAINT_NAME.equal(KeyColumnUsage.CONSTRAINT_NAME))
.join(KEY_COLUMN_USAGE) .on(KEY_COLUMN_USAGE.CONSTRAINT_SCHEMA.equal(REFERENTIAL_CONSTRAINTS.CONSTRAINT_SCHEMA)) .and(KEY_COLUMN_USAGE.CONSTRAINT_NAME.equal(REFERENTIAL_CONSTRAINTS.CONSTRAINT_NAME)) .where(KEY_COLUMN_USAGE.TABLE_SCHEMA.in(getInputSchemata())) .orderBy(
.and(PG_PROC.PRONAME.concat("_").concat(oid(PG_PROC)).eq(r1.SPECIFIC_NAME)) .where(r1.ROUTINE_SCHEMA.in(getInputSchemata())) .and(tableValuedFunctions()
.join(name("domains")) .on(field(name("domains", "typbasetype")).eq(0)) .and(field(name("domains", "domain_id")).eq(oid(d))) .join(b) .on(field(name("domains", "base_id")).eq(oid(b)))