private Select<? extends Record> getLatestTimestampQueryAllColumnsSubQuery(DSLContext ctx, TableReference tableRef, Select<Record1<byte[]>> subQuery, long timestamp) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.in(subQuery) .and(A_TIMESTAMP.lessThan(timestamp))) .groupBy(A_ROW_NAME, A_COL_NAME); }
private Select<? extends Record> getLatestTimestampQueryAllColumns(DSLContext ctx, TableReference tableRef, Collection<byte[]> rows, long timestamp) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.in(rows) .and(A_TIMESTAMP.lessThan(timestamp))) .groupBy(A_ROW_NAME, A_COL_NAME); }
private Select<? extends Record> getLatestTimestampQuerySomeColumns(DSLContext ctx, TableReference tableRef, Collection<byte[]> rows, Collection<byte[]> cols, long timestamp) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.in(rows) .and(A_COL_NAME.in(cols))) .and(A_TIMESTAMP.lessThan(timestamp)) .groupBy(A_ROW_NAME, A_COL_NAME); }
private Select<? extends Record> getLatestTimestampQuerySomeColumnsSubQuery(DSLContext ctx, TableReference tableRef, Select<Record1<byte[]>> subQuery, Collection<byte[]> cols, long timestamp) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.in(subQuery) .and(A_COL_NAME.in(cols))) .and(A_TIMESTAMP.lessThan(timestamp)) .groupBy(A_ROW_NAME, A_COL_NAME); }
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); }
.from(table) .where(whereCondition) .groupBy(groupByFields) .orderBy(orderByFields));
ZIPKIN_SPANS.START_TS.between(endTs - lookback * 1000, endTs)) .groupBy(ZIPKIN_SPANS.TRACE_ID, ZIPKIN_SPANS.ID, ZIPKIN_ANNOTATIONS.A_KEY).fetchLazy();
ZIPKIN_SPANS.START_TS.between(endTs - lookback * 1000, endTs)) .groupBy(ZIPKIN_SPANS.TRACE_ID, ZIPKIN_SPANS.ID, ZIPKIN_ANNOTATIONS.A_KEY).fetchLazy();
.from(PROCESS_INSTANCE) .where(PROCESS_INSTANCE.END_TIME.isNull()) .groupBy(PROCESS_INSTANCE.PROCESS_NAME, running, delayed) .fetchInto(new RecordHandler<Record4<String, Boolean, Boolean, Integer>>() { @Override
ZIPKIN_SPANS.START_TS.between(endTs - lookback * 1000, endTs)) .groupBy(ZIPKIN_SPANS.TRACE_ID, ZIPKIN_SPANS.ID, ZIPKIN_ANNOTATIONS.A_KEY).fetchLazy();
@Override public PageResult<Tag> page(PageResult<Tag> page) { return dao.fetch(page, e -> { return e.select(Fields.all(C_TAG.fields(), DSL.count(C_ARTICLE_TAG.ARTICLE_ID).as("articleCount"))).from(C_TAG,C_ARTICLE_TAG) .where(C_TAG.ID.eq(C_ARTICLE_TAG.TAG_ID)) .groupBy(C_ARTICLE_TAG.TAG_ID); }, Tag.class); } }
public Map<String, List<ProjectProcesses>> processByOrgs(int maxProjectRows, Set<UUID> orgIds, Set<ProcessStatus> processStatuses, Timestamp fromUpdatedAt) { Set<String> statuses = processStatuses.stream().map(Enum::name).collect(Collectors.toSet()); try (DSLContext tx = DSL.using(cfg)) { WindowRowsStep<Integer> rnField = rowNumber().over().partitionBy(V_PROCESS_QUEUE.ORG_NAME).orderBy(V_PROCESS_QUEUE.ORG_NAME); SelectHavingStep<Record4<String, String, Integer, Integer>> a = tx.select(V_PROCESS_QUEUE.ORG_NAME, V_PROCESS_QUEUE.PROJECT_NAME, count(), rnField) .from(V_PROCESS_QUEUE) .where(V_PROCESS_QUEUE.ORG_ID.in(orgIds) .and(V_PROCESS_QUEUE.CURRENT_STATUS.in(statuses)) .and(V_PROCESS_QUEUE.LAST_UPDATED_AT.greaterOrEqual(fromUpdatedAt))) .groupBy(V_PROCESS_QUEUE.ORG_NAME, V_PROCESS_QUEUE.PROJECT_NAME); Result<Record3<String, String, Integer>> r = tx.select(a.field(0, String.class), a.field(1, String.class), a.field(2, Integer.class)) .from(a) .where(a.field(rnField).lessOrEqual(maxProjectRows)) .fetch(); Map<String, List<ProjectProcesses>> result = new HashMap<>(); r.forEach(i -> { String orgName = i.value1(); String projectName = i.value2(); int count = i.value3(); result.computeIfAbsent(orgName, (k) -> new ArrayList<>()).add(new ProjectProcesses(projectName, count)); }); return result; } } }
ZIPKIN_SPANS.START_TS.between(endTs - lookback * 1000, endTs)) .groupBy(schema.dependencyLinkerGroupByFields).fetchLazy();
.groupBy(schema.spanIdFields) .orderBy(ZIPKIN_SPANS.START_TS.max().desc()).limit(request.limit);
public List<Catalog> findAllDetail() { return dao.execute(e -> { return e.select(Fields.all(C_CATALOG.fields(), DSL.count(C_ARTICLE.ID).as("articleCount"))).from(C_ARTICLE) .leftJoin(C_CATALOG).on(C_CATALOG.ID.eq(C_ARTICLE.CATALOG_ID)) .where(C_ARTICLE.STATUS.eq(Article.STATUS_PUBLISH)) .groupBy(C_CATALOG.ID) .orderBy(C_CATALOG.SORT).fetch(r -> { return dao.mapperEntityEx(r, Catalog.class); }); }); } }
.join(project_cost).using(project_info.field("project_pid")) .where(total_cost.greaterThan(new BigDecimal(totalCostBoundary))) .groupBy(project_name, total_cost, company_name) .orderBy(company_name);