Method processExpression

query/time_series_aggregate.go:462–562

processExpression does AST tree dfs traversal and apply root action on the root level, rootAction includes filterAction, writeToDimensionVectorAction and makeWriteToMeasureVectorAction

(exp, parentExp expr.Expr, tableScanners []*TableScanner, foreignTables []*foreignTable,
	stream unsafe.Pointer, device int, action rootAction)

// processExpression does AST tree dfs traversal and apply root action on the root level,
// rootAction includes filterAction, writeToDimensionVectorAction and makeWriteToMeasureVectorAction
func (bc *oopkBatchContext) processExpression(exp, parentExp expr.Expr, tableScanners []*TableScanner, foreignTables []*foreignTable,
	stream unsafe.Pointer, device int, action rootAction) C.InputVector {
	switch e := exp.(type) {
	case *expr.ParenExpr:
		return bc.processExpression(e.Expr, e, tableScanners, foreignTables, stream, device, action)
	case *expr.VarRef:
		columnIndex := tableScanners[e.TableID].ColumnsByIDs[e.ColumnID]
		var inputVector C.InputVector
		// main table
		if e.TableID == 0 {
			column := bc.columns[columnIndex]
			inputVector = makeVectorPartySliceInput(column)
		} else {
			var timezoneLookup unsafe.Pointer
			var timezoneLookupDSize int
			switch pe := parentExp.(type) {
			case *expr.BinaryExpr:
				if pe.Op == expr.CONVERT_TZ {
					timezoneLookup = bc.timezoneLookupD.getPointer()
					timezoneLookupDSize = bc.timezoneLookupDSize
				}
			default:
			}
			inputVector = makeForeignColumnInput(columnIndex, bc.foreignTableRecordIDsD[e.TableID-1].getPointer(), *foreignTables[e.TableID-1], timezoneLookup, timezoneLookupDSize)
		}

		if action != nil {
			action(C.Noop, stream, device, []C.InputVector{inputVector}, e)
			return C.InputVector{}
		}
		return inputVector
	case *expr.NumberLiteral, *expr.GeopointLiteral:
		var inputVector C.InputVector
		inputVector = makeConstantInput(e, true)
		if action != nil {
			action(C.Noop, stream, device, []C.InputVector{inputVector}, e)
			return C.InputVector{}
		}
		return inputVector
	case *expr.UnaryExpr:
		inputVector := bc.processExpression(e.Expr, e, tableScanners, foreignTables, stream, device, nil)
		functorType, exist := UnaryExprTypeToCFunctorType[e.Op]
		if !exist {
			functorType = C.Noop
		}

		if action != nil {
			action(functorType, stream, device, []C.InputVector{inputVector}, e)
			return C.InputVector{}
		}

		values, nulls := bc.allocateStackFrame()
		dataType := getOutputDataType(e.Type(), 4)
		var outputVector = makeScratchSpaceOutput(values.getPointer(), nulls.getPointer(), dataType)

		C.UnaryTransform(inputVector, outputVector, (*C.uint32_t)(bc.indexVectorD.getPointer()),
			(C.int)(bc.size), (*C.uint32_t)(bc.baseCountD.getPointer()), (C.uint32_t)(bc.startRow), functorType, stream, C.int(device))