func()

in query/aql_compiler.go [344:437]
81 lines of code
23 McCabe index (conditional complexity)

func (qc *AQLQueryContext) parseExprs() {
	var err error

	// Join conditions.
	for i, join := range qc.Query.Joins {
		join.ConditionsParsed = make([]expr.Expr, len(join.Conditions))
		for j, cond := range join.Conditions {
			join.ConditionsParsed[j], err = expr.ParseExpr(cond)
			if err != nil {
				qc.Error = utils.StackError(err, "Failed to parse join condition: %s", cond)
				return
			}
		}
		qc.Query.Joins[i] = join
	}

	qc.fromTime, qc.toTime, qc.Error = common.ParseTimeFilter(qc.Query.TimeFilter, qc.fixedTimezone, utils.Now())
	if qc.Error != nil {
		return
	}

	// Filters.
	qc.Query.FiltersParsed = make([]expr.Expr, len(qc.Query.Filters))
	for i, filter := range qc.Query.Filters {
		qc.Query.FiltersParsed[i], err = expr.ParseExpr(filter)
		if err != nil {
			qc.Error = utils.StackError(err, "Failed to parse filter %s", filter)
			return
		}
	}
	if qc.fromTime == nil && qc.toTime == nil && len(qc.TableScanners) > 0 && qc.TableScanners[0].Schema.Schema.IsFactTable {
		qc.adjustFilterToTimeFilter()
		if qc.Error != nil {
			return
		}
	}

	// Dimensions.
	rawDimensions := qc.Query.Dimensions
	qc.Query.Dimensions = []common.Dimension{}
	for _, dim := range rawDimensions {
		dim.TimeBucketizer = strings.Trim(dim.TimeBucketizer, " ")
		if dim.TimeBucketizer != "" {
			// make sure time column is defined
			if dim.Expr == "" {
				qc.Error = utils.StackError(err, "Failed to parse TimeSeriesBucketizer '%s' since time column is empty ", dim.TimeBucketizer)
				return
			}

			timeColumnExpr, err := expr.ParseExpr(dim.Expr)
			if err != nil {
				qc.Error = utils.StackError(err, "Failed to parse timeColumn '%s'", dim.Expr)
				return
			}

			dim.ExprParsed, err = qc.buildTimeDimensionExpr(dim.TimeBucketizer, timeColumnExpr)
			if err != nil {
				qc.Error = utils.StackError(err, "Failed to parse dimension: %s", dim.TimeBucketizer)
				return
			}
			qc.Query.Dimensions = append(qc.Query.Dimensions, dim)
		} else {
			// dimension is defined as sqlExpression
			dim.ExprParsed, err = expr.ParseExpr(dim.Expr)
			if err != nil {
				qc.Error = utils.StackError(err, "Failed to parse dimension: %s", dim.Expr)
				return
			}
			if _, ok := dim.ExprParsed.(*expr.Wildcard); ok {
				qc.Query.Dimensions = append(qc.Query.Dimensions, qc.getAllColumnsDimension()...)
			} else {
				qc.Query.Dimensions = append(qc.Query.Dimensions, dim)
			}
		}
	}

	// Measures.
	for i, measure := range qc.Query.Measures {
		measure.ExprParsed, err = expr.ParseExpr(measure.Expr)
		if err != nil {
			qc.Error = utils.StackError(err, "Failed to parse measure: %s", measure.Expr)
			return
		}
		measure.FiltersParsed = make([]expr.Expr, len(measure.Filters))
		for j, filter := range measure.Filters {
			measure.FiltersParsed[j], err = expr.ParseExpr(filter)
			if err != nil {
				qc.Error = utils.StackError(err, "Failed to parse measure filter %s", filter)
				return
			}
		}
		qc.Query.Measures[i] = measure
	}
}