camel case

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 ');
 };