camel case

lib/models/aggregation/aggregation-mapconfig.js

@@ -83,7 +83,7 @@ module.exports = class AggregationMapConfig extends MapConfig {
     }
 
     getAggregatedQuery (index) {
-        const { sql_raw, sql } = this.getLayer(index).options;
+        const { sql_raw: sqlRaw, sql } = this.getLayer(index).options;
         const {
             // The default aggregation has no placement, columns or dimensions;
             // this enables the special "full-sample" aggregation.
@@ -96,7 +96,7 @@ module.exports = class AggregationMapConfig extends MapConfig {
         } = this.getAggregation(index);
 
         return aggregationQuery({
-            query: sql_raw || sql,
+            query: sqlRaw || sql,
             resolution,
             threshold,
             placement,

lib/models/aggregation/aggregation-query.js

@@ -51,22 +51,22 @@ module.exports.infoForOptions = (options) => {
 
 const SUPPORTED_AGGREGATE_FUNCTIONS = {
     count: {
-        sql: (column_name, params) => `count(${params.aggregated_column || '*'})`
+        sql: (columnName, params) => `count(${params.aggregated_column || '*'})`
     },
     avg: {
-        sql: (column_name, params) => `avg(${params.aggregated_column || column_name})`
+        sql: (columnName, params) => `avg(${params.aggregated_column || columnName})`
     },
     sum: {
-        sql: (column_name, params) => `sum(${params.aggregated_column || column_name})`
+        sql: (columnName, params) => `sum(${params.aggregated_column || columnName})`
     },
     min: {
-        sql: (column_name, params) => `min(${params.aggregated_column || column_name})`
+        sql: (columnName, params) => `min(${params.aggregated_column || columnName})`
     },
     max: {
-        sql: (column_name, params) => `max(${params.aggregated_column || column_name})`
+        sql: (columnName, params) => `max(${params.aggregated_column || columnName})`
     },
     mode: {
-        sql: (column_name, params) => `mode() WITHIN GROUP (ORDER BY ${params.aggregated_column || column_name})`
+        sql: (columnName, params) => `mode() WITHIN GROUP (ORDER BY ${params.aggregated_column || columnName})`
     }
 };
 
@@ -85,20 +85,20 @@ const aggregateColumns = ctx => {
     }, ctx.columns || {});
 };
 
-const aggregateExpression = (column_name, column_parameters) => {
-    const aggregate_function = column_parameters.aggregate_function || 'count';
-    const aggregate_definition = SUPPORTED_AGGREGATE_FUNCTIONS[aggregate_function];
-    if (!aggregate_definition) {
-        throw new Error("Invalid Aggregate function: '" + aggregate_function + "'");
+const aggregateExpression = (columnName, columnParameters) => {
+    const aggregateFunction = columnParameters.aggregate_function || 'count';
+    const aggregateDefinition = SUPPORTED_AGGREGATE_FUNCTIONS[aggregateFunction];
+    if (!aggregateDefinition) {
+        throw new Error("Invalid Aggregate function: '" + aggregateFunction + "'");
     }
-    return aggregate_definition.sql(column_name, column_parameters);
+    return aggregateDefinition.sql(columnName, columnParameters);
 };
 
 const aggregateColumnDefs = ctx => {
     const columns = aggregateColumns(ctx);
-    return sep(Object.keys(columns).map(column_name => {
-        const aggregate_expression = aggregateExpression(column_name, columns[column_name]);
-        return `${aggregate_expression} AS ${column_name}`;
+    return sep(Object.keys(columns).map(columnName => {
+        const aggregate = aggregateExpression(columnName, columns[columnName]);
+        return `${aggregate} AS ${columnName}`;
     }));
 };
 
@@ -241,17 +241,17 @@ const filterConditions = ctx => {
     const columns = aggregateColumns(ctx);
     const dimensions = aggregateDimensions(ctx);
     const filters = aggregateFilters(ctx);
-    return Object.keys(filters).map(filtered_column => {
-        let filtered_expr;
-        if (columns[filtered_column]) {
-            filtered_expr = aggregateExpression(filtered_column, columns[filtered_column]);
-        } else if (dimensions[filtered_column]) {
-            filtered_expr = dimensions[filtered_column];
+    return Object.keys(filters).map(filteredColumn => {
+        let filteredExpr;
+        if (columns[filteredColumn]) {
+            filteredExpr = aggregateExpression(filteredColumn, columns[filteredColumn]);
+        } else if (dimensions[filteredColumn]) {
+            filteredExpr = dimensions[filteredColumn];
         }
-        if (!filtered_expr) {
-            throw new Error("Invalid filtered column: '" + filtered_column + "'");
+        if (!filteredExpr) {
+            throw new Error("Invalid filtered column: '" + filteredColumn + "'");
         }
-        return filterConditionSQL(filtered_expr, filters[filtered_column]);
+        return filterConditionSQL(filteredExpr, filters[filteredColumn]);
     }).join(' AND ');
 };
 

lib/models/aggregation/aggregation-validator.js

@@ -90,10 +90,10 @@ function createAggregationColumnNamesValidator (mapconfig) {
 function createAggregateFunctionValidator (mapconfig, validAggregatedFunctions) {
     return function validateAggregateFunction (value, key, index) {
         Object.keys(value).forEach((columnName) => {
-            const { aggregate_function } = value[columnName];
+            const { aggregate_function: aggregateFunction } = value[columnName];
 
-            if (!validAggregatedFunctions.includes(aggregate_function)) {
-                const message = `Unsupported aggregation function ${aggregate_function},` +
+            if (!validAggregatedFunctions.includes(aggregateFunction)) {
+                const message = `Unsupported aggregation function ${aggregateFunction},` +
                                 ` valid ones: ${validAggregatedFunctions.join(', ')}`;
                 throw createLayerError(message, mapconfig, index);
             }
@@ -104,9 +104,9 @@ function createAggregateFunctionValidator (mapconfig, validAggregatedFunctions)
 function createAggregatedColumnValidator (mapconfig) {
     return function validateAggregatedColumn (value, key, index) {
         Object.keys(value).forEach((columnName) => {
-            const { aggregated_column } = value[columnName];
+            const { aggregated_column: aggregatedColumn } = value[columnName];
 
-            if (typeof aggregated_column !== 'string' || aggregated_column <= 0) {
+            if (typeof aggregatedColumn !== 'string' || aggregatedColumn <= 0) {
                 const message = 'Invalid aggregated column, should be a non empty string';
                 throw createLayerError(message, mapconfig, index);
             }

lib/models/aggregation/time-dimension.js

@@ -187,12 +187,12 @@ function validateParameters (params, checker) {
     if (missingParams.length) {
         errors.push(`Missing parameters: ${missingParams.join(', ')}`);
     }
-    const params_errors = checker(params);
-    errors.push(...params_errors.errors);
+    const paramsErrors = checker(params);
+    errors.push(...paramsErrors.errors);
     if (errors.length) {
         throw new Error(`Invalid time dimension:\n${errors.join('\n')}`);
     }
-    return params_errors.params;
+    return paramsErrors.params;
 }
 
 const VALID_CYCLIC_UNITS = Object.keys(cyclicParts);