externalPreAggregationQuery() { if (!this.options.preAggregationQuery && this.externalQueryClass) { const preAggregationForQuery = this.preAggregations.findPreAggregationForQuery(); if (preAggregationForQuery && preAggregationForQuery.preAggregation.external) { return true; } const preAggregationsDescription = this.preAggregations.preAggregationsDescription(); return preAggregationsDescription.length && R.all((p) => p.external, preAggregationsDescription); } return false; }
findAutoRollupPreAggregationsForCube(cube, preAggregations) { if ( R.any(m => m.path() && m.path()[0] === cube, this.query.measures) || !this.query.measures.length && !this.query.timeDimensions.length && R.all(d => d.path() && d.path()[0] === cube, this.query.dimensions) ) { return R.pipe( R.toPairs, // eslint-disable-next-line no-unused-vars R.filter(([k, a]) => a.type === 'autoRollup'), R.map(([preAggregationName, preAggregation]) => { const cubeLattice = this.getCubeLattice(cube, preAggregationName, preAggregation); const optimalPreAggregation = cubeLattice.findOptimalPreAggregationFromLattice(this.query); return optimalPreAggregation && { preAggregationName: preAggregationName + this.autoRollupNameSuffix(cube, optimalPreAggregation), preAggregation: Object.assign( optimalPreAggregation, preAggregation ), cube, canUsePreAggregation: true, references: optimalPreAggregation }; }) )(preAggregations); } return []; }
R.all(d => query.dimensions.map(dim => dim.dimension).indexOf(d) !== -1)( query.filters.map(f => f.dimension) ); const isAdditive = R.all(m => m.isAdditive(), query.measures); const leafMeasureAdditive = R.all(path => query.newMeasure(path).isAdditive(), leafMeasurePaths); const granularityHierarchies = query.granularityHierarchies(); const hasMultipliedMeasures = query.fullKeyQueryAggregateMeasures().multipliedMeasures.length > 0;
R.equals(references.sortedDimensions || references.dimensions, transformedQuery.sortedDimensions) && R.all(m => references.measures.indexOf(m) !== -1, transformedQuery.measures) || R.all(m => references.measures.indexOf(m) !== -1, transformedQuery.leafMeasures) ) && R.equals( ); const canUsePreAggregationLeafMeasureAdditive = (references) => R.all( d => (references.sortedDimensions || references.dimensions).indexOf(d) !== -1, transformedQuery.sortedDimensions ) && R.all(m => references.measures.indexOf(m) !== -1, transformedQuery.leafMeasures) && R.allPass( queryTimeDimensionsList.map(tds => R.anyPass(tds.map(td => R.contains(td))))
}, transaction.data.inputs); if (R.all(R.equals(false), transactionInputFoundAnywhere)) { if (transaction.type === 'regular' && negativeOutputsFound === 0) { selectedTransactions.push(transaction);
// use :: ((IncomingMessage, HttpResponse, Function) -> ()) -> Request -> Request const use = middle => ifElse( compose(all(Boolean), props([ 'request', 'response' ])), applyMiddleware(middle), tapP(warn('`use` is not supported in lambdas.')), )
const someFail = results => R.not(R.all(R.equals(true), Object.values(results)))
return R.all(todo => todo.completed, this.todos) }, get leftCount () {