Set time periods in the query

InfluxDB 2
1

Hello. In the following query I obtain the money that I have to pay for electricity in a certain period of time, from one date to another, as I choose.
I would like to know how to set this time interval so that the query gives me the electricity expense for the current month (I would also like to know for the past month, for this week, for the past week,…)

import "math"
importada = from(bucket: "energymeter")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

kWhresultantes = join(tables: {key1: importada, key2: exportada}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({
    _time: r._time,
    _field: "kWhresultantes",
    _value: ((r._value_key1 - r._value_key2)),
  })) 
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

costekWhimportado = kWhresultantes
  |> map(fn: (r) => ({ 
    _time: r._time,
    _field: "costekWhimportado",
    _value: if r._value > 0 then r._value * 0.19 else 0.0}))  
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

costekWhexportado = kWhresultantes
  |> map(fn: (r) => ({ 
    _time: r._time,
    _field: "costekWhexportado",
    _value: if r._value < 0 then r._value * 0.15 else 0.0}))  
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

costehorario = join(tables: {key3: costekWhimportado, key4: costekWhexportado}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({
    _time: r._time,
    _value: ((r._value_key3 + r._value_key4)),
  })) 
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  |> sum(column: "_value")
  |> map(fn: (r) => ({ r with coste: r._value}))
  |> drop(columns: ["_value"])
  |> yield()
2

I answer myself:
For today:

import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
importada = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1d))
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1d))
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

precioimportado = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1d))
  |> filter(fn: (r) => r._measurement == "PRECIO_IMPORTADO")
  |> filter(fn: (r) => r._field == "precio")
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

precioexportado = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1d))
  |> filter(fn: (r) => r._measurement == "PRECIO_EXPORTADO")
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

kWhresultantes = join(tables: {key1: importada, key2: exportada}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({
    _time: r._time,
    _value: ((r._value_key1 - r._value_key2)),
  })) 
  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
costekWhimportado = join(tables: {key3: kWhresultantes, key4: precioimportado}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({ 
    _time: r._time,
    _value: if r._value_key3 > 0 then r._value_key3 * r._value_key4 else 0.0
  })) 
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

costekWhexportado = join(tables: {key5: kWhresultantes, key6: precioexportado}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({ 
    _time: r._time,
    _value: if r._value_key5 < 0 then r._value_key5 * r._value_key6 else 0.0
  })) 
  |> aggregateWindow(every: 1h, fn: last, createEmpty: false, timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])

costehorario = join(tables: {key7: costekWhimportado, key8: costekWhexportado}, on: ["_time"], method: "inner")
  |> map(fn: (r) => ({r with _time: r._time, _value: ((r._value_key7 + r._value_key8)) }))
  |> sum(column: "_value")
  |> map(fn: (r) => ({ r with a_pagar: r._value}))
  |> drop(columns: ["_value"])
  |> yield()

For this week:

import "experimental/date/boundaries"
import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
thisWeek = boundaries.week()

importada = from(bucket: "energymeter")
  |> range(start: thisWeek.start, stop: thisWeek.stop)
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: thisWeek.start, stop: thisWeek.stop)
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
.
.
.

For this month:

import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
importada = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1mo))
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: date.truncate(t: now(), unit: 1mo))
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
.
.
.
.

For yesterday:

import "experimental/date/boundaries"
import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
day = boundaries.yesterday()

importada = from(bucket: "energymeter")
  |> range(start: day.start, stop: day.stop)
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: day.start, stop: day.stop)
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
.
.
.
.

For last week:

import "experimental/date/boundaries"
import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
lastWeek = boundaries.week(week_offset: -1)

importada = from(bucket: "energymeter")
  |> range(start: lastWeek.start, stop: lastWeek.stop)
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: lastWeek.start, stop: lastWeek.stop)
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
.
.
.
.
.

For last month:

import "experimental/date/boundaries"
import "date"
import "math"
import "timezone"
option location = timezone.location(name: "Europe/Madrid")
lastMonth = boundaries.month(month_offset: -1)

importada = from(bucket: "energymeter")
  |> range(start: lastMonth.start, stop: lastMonth.stop)
  |> filter(fn: (r) => r._measurement == "IMPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
  
exportada = from(bucket: "energymeter")
  |> range(start: lastMonth.start, stop: lastMonth.stop)
  |> filter(fn: (r) => r._measurement == "EXPORTADA")
  |> aggregateWindow(
    every: 1h,
    fn: (tables=<-, column) =>
      tables
        |> integral(unit: 1h)
        |> map(fn: (r) => ({ r with _value: r._value / 1000.0})), timeSrc: "_start")
  |> keep(columns: ["_time", "_value"])
3

@s118.,
Thanks so much for sharing your solution with the community!