const toConfigMap = (metaConfig) => ( R.pipe( R.map(c => [c.config.name, c.config]), R.fromPairs )(metaConfig) )
static hasCumulativeMeasures(query) { const measures = (query.measures.concat(query.measureFilters)); const collectLeafMeasures = query.collectLeafMeasures.bind(query); return R.pipe( R.map(m => query.collectFrom([m], collectLeafMeasures, 'collectLeafMeasures')), R.unnest, R.uniq, R.map(p => query.newMeasure(p)), R.any(m => m.isCumulative()) )(measures); }
collectLeafMeasures(fn) { const context = { leafMeasures: {} }; this.evaluateSymbolSqlWithContext( fn, context ); return R.pipe( R.toPairs, R.map(([measure, isLeaf]) => isLeaf && measure), R.filter(R.identity) )(context.leafMeasures); }
preAggregationsDescription() { return R.pipe(R.unnest, R.uniqBy(desc => desc.tableName))( [this.preAggregationsDescriptionLocal()].concat( this.query.subQueryDimensions.map(d => this.query.subQueryDescription(d).subQuery) .map(q => q.preAggregations.preAggregationsDescription()) ) ); }
orderBy() { if (R.isEmpty(this.order)) { return ''; } const orderByString = R.pipe( R.map(this.orderHashToString), R.reject(R.isNil), R.join(', ') )(this.order); if (!orderByString) { return ''; } return ` ORDER BY ${orderByString}`; }
dimensionColumns(tableDefinition) { const dimensionColumns = tableDefinition.filter( column => !column.name.startsWith('_') && this.columnType(column) === 'string' || column.attributes && column.attributes.indexOf('primaryKey') !== -1 || column.name.toLowerCase() === 'id' ); const timeColumns = R.pipe( R.filter(column => !column.name.startsWith('_') && this.columnType(column) === 'time'), R.sortBy(column => this.timeColumnIndex(column)), R.map(column => ({ ...column, columnType: 'time' })) // TODO do we need it? )(tableDefinition); return dimensionColumns.concat(timeColumns); }
findPreAggregationToUseForCube(cube) { const preAggregates = this.query.cubeEvaluator.preAggregationsForCube(cube); const originalSqlPreAggregations = R.pipe( R.toPairs, // eslint-disable-next-line no-unused-vars R.filter(([k, a]) => a.type === 'originalSql') )(preAggregates); if (originalSqlPreAggregations.length) { const [preAggregationName, preAggregation] = originalSqlPreAggregations[0]; return { preAggregationName, preAggregation, cube, references: this.evaluateAllReferences(cube, preAggregation) }; } return null; }
queueArray(queueObj, orderFilterLessThan) { return R.pipe( R.values, R.filter(orderFilterLessThan ? q => q.order < orderFilterLessThan : R.identity), R.sortBy(q => q.order), R.map(q => q.key) )(queueObj); }
static squashDimensions(query) { return R.pipe(R.uniq, R.sortBy(R.identity))( query.dimensions.concat(query.filters).map(d => d.dimension).concat(query.segments.map(s => s.segment)) ); }
collectFrom(membersToCollectFrom, fn, methodName, cache) { return R.pipe( R.map(f => f.getMembers()), R.flatten, R.map(s => ( (cache || this.compilerCache).cache( ['collectFrom', methodName].concat( s.path() ? [s.path().join('.')] : [s.cube().name, s.expressionName || s.definition().sql] ), () => fn(() => this.traverseSymbol(s)) ) )), R.unnest, R.uniq, R.filter(R.identity) )( membersToCollectFrom ); }
rollupMatchResults() { const { query } = this; if (PreAggregations.hasCumulativeMeasures(query)) { return []; } const canUsePreAggregation = this.canUsePreAggregationFn(query); return R.pipe( R.map(cube => { const preAggregations = this.query.cubeEvaluator.preAggregationsForCube(cube); let rollupPreAggregations = this.findRollupPreAggregationsForCube(cube, canUsePreAggregation, preAggregations); rollupPreAggregations = rollupPreAggregations.concat( this.findAutoRollupPreAggregationsForCube(cube, preAggregations) ); return rollupPreAggregations; }), R.unnest )(query.collectCubeNames()); }
const getQueryGranularity = (queries) => R.pipe( R.map(({ timeDimensions }) => timeDimensions[0] && timeDimensions[0].granularity || null), R.filter(Boolean), R.uniq )(queries)
compile(cubes, errorReporter) { this.cubeDefinitions = R.pipe( R.map(c => [c.name, c]), R.fromPairs )(cubes); this.cubeList = cubes.map(c => (c.name ? this.getCubeDefinition(c.name) : this.createCube(c))); this.symbols = R.pipe( R.map((c) => [c.name, this.transform(c.name, errorReporter.inContext(`${c.name} cube`))]), R.fromPairs )(cubes); }
findRollupPreAggregationsForCube(cube, canUsePreAggregation, preAggregations) { return R.pipe( R.toPairs, // eslint-disable-next-line no-unused-vars R.filter(([k, a]) => a.type === 'rollup'), R.map(([preAggregationName, preAggregation]) => { const references = this.evaluateAllReferences(cube, preAggregation); return { preAggregationName, preAggregation, cube, canUsePreAggregation: canUsePreAggregation(references), references }; }) )(preAggregations); }
R.pipe( R.map(s => [s.id, s]), R.fromPairs )