const toConfigMap = (metaConfig) => ( R.pipe( R.map(c => [c.config.name, c.config]), R.fromPairs )(metaConfig) )
async getQueryStageState(onlyKeys) { let request = this.redisClient.multi() .zrange([this.activeRedisKey(), 0, -1]) .zrange([this.toProcessRedisKey(), 0, -1]); if (!onlyKeys) { request = request.hgetall(this.queriesDefKey()); } const [active, toProcess, allQueryDefs] = await request.execAsync(); return [active, toProcess, R.map(q => JSON.parse(q), allQueryDefs || {})]; }
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); }
// eslint-disable-next-line no-unused-vars compile(contexts, errorReporter) { if (contexts.length === 0) { return; } // TODO: handle duplications, context names must be uniq this.contextDefinitions = R.compose( R.fromPairs, R.map(v => [v.name, this.compileContext(v)]) )(contexts); }
function extract (root, data, type) { const input = R.path(root, data); if (typeof input === 'undefined') { return []; } const MAPPINGS = getPermissionMappings(type); return R.map(scriptData.extractor(MAPPINGS), input); }
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); }
timeDimensionPathsForCube(cube) { return R.compose( R.map(nameToDefinition => `${cube}.${nameToDefinition[0]}`), R.toPairs, R.filter(d => d.type === 'time') )(this.evaluatedCubes[cube].dimensions || {}); }
buildJoinNode(cube) { return R.compose( R.fromPairs, R.map(v => [v[0], 1]), R.toPairs )(cube.joins || {}); }
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); }
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); }
async query(query, values, options) { const data = await this.runQueryJob({ query, params: values, parameterMode: 'positional', useLegacySql: false }, options); return data[0] && data[0].map( row => R.map(value => (value && value.value && typeof value.value === 'string' ? value.value : value), row) ); }
/* * Apply MAPPINGS for each application in list from root path */ function extract (root, data) { const input = R.path(root, data); if (input === undefined) return []; return R.map(scriptData.extractor(MAPPINGS), input); }
const getQueryGranularity = (queries) => R.pipe( R.map(({ timeDimensions }) => timeDimensions[0] && timeDimensions[0].granularity || null), R.filter(Boolean), R.uniq )(queries)
/* * Apply MAPPINGS for each application in list from root path */ function extract (root, data, appId) { const input = R.path(root, data); const MAPPINGS = getReviewsMappings(appId); return R.map(scriptData.extractor(MAPPINGS), input); }