ES:API de Overpass/Overpass QL

From OpenStreetMap Wiki
Jump to navigation Jump to search
Overpass API logo.svg
edit
API de Overpass · Referencia de lenguaje · Guía de lenguaje · Términos técnicos · Áreas · Ejemplos de consultas · Ejemplos avanzados · Edición dispersa · ID permanente · Preguntas frecuentes · más (español) · Sitio web
Estado de servidores · Versiones · Desarrollo · Diseño técnico · Instalación · Capa de compatibilidad XAPI · Esquemas de transporte público · Aplicaciones · Código fuente e incidencias
Overpass turbo · Asistente · Atajos de Overpass turbo · Hojas de estilo MapCSS · Exportar a GeoJSON · más (español) · Desarrollo · Código fuente e incidencias · Sitio web

Overpass QL (abreviatura de «Overpass Query Language»; en español: «Lenguaje de consulta Overpass») es el segundo lenguaje de consulta creado para la API de Overpass; el primero fue Overpass XML. Overpass QL es un lenguaje de programación por procedimientos imperativo escrito con una sintaxis estilo C.

Esta página wiki pretende ser una referencia completa a la estructura de Overpass QL. Para una colección de ejemplos prácticos, véase la página wiki API de Overpass por ejemplo. Las personas sin conocimientos técnicos pueden encontrar esa otra página más accesible.

Resumen del lenguaje

Declaraciones

El código fuente de Overpass QL se divide en declaraciones, y cada declaración finaliza con un punto y coma ;. Las declaraciones se ejecutan secuencialmente mediante un proceso, y cada ejecución de declaración cambia el estado de ejecución del proceso.

Estado de ejecución

El estado de ejecución de Overpass QL consiste en:

  • el conjunto predeterminado _ (un solo subrayado)
  • otros conjuntos con nombre, si son creados por el usuario
  • una pila, durante la ejecución de las declaraciones de bloqueo de Overpass QL

Conjuntos

Overpass QL manipula conjuntos. Las declaraciones escriben sus resultados en conjuntos, y los conjuntos son leídos por las declaraciones subsiguientes como entradas. Un conjunto de Overpass QL puede contener cualquier combinación de (y cualquier número de) nodos, vías, relaciones y elementos área de OpenStreetMap.

A menos que se especifique un conjunto con nombre como entrada o resultado, toda entrada se lee implícitamente del (y todos los resultados se escribirán en el) conjunto predeterminado con nombre _ (un solo subrayado). Una vez que un nuevo resultado se asigna (implícita o explícitamente) a un conjunto existente, su contenido anterior será reemplazado y ya no estará disponible. Los conjuntos de Overpass QL siempre tienen ámbito (visibilidad) global.

Por ejemplo:

  node[name="Foo"];

simplemente escribe el resultado de la consulta de etiqueta nombre="Foo" en el conjunto predeterminado _, sobrescribiendo cualquier contenido anterior con este resultado. Un resultado puede ser escrito en un conjunto específico usando la sintaxis ->, cuando al nombre de ese conjunto se le antepone un punto .. La declaración anterior equivale, por tanto, a:

  node[name="Foo"]->._;

De forma similar, esta declaración:

 (
  node[name="Foo"];
  node[name="Bar"];
 );

combina los resultados de dos consultas de etiquetas con una declaración de unión, y luego envía ese resultado al conjunto predeterminado _. Es equivalente a:

 (
  node[name="Foo"];
  node[name="Bar"];
 )->._;

Para escribir elementos en un conjunto con nombre, usa la sintaxis ->, seguido del nombre del conjunto. Por ejemplo, esta consulta:

  (node[name="Foo"];)->.a;

escribirá todos los elementos tipo nodo con la etiqueta name=Foo en el conjunto con nombre a. Los nombres de los conjuntos pueden consistir en letras, dígitos y el subrayado; sin embargo, no deben comenzar con un dígito.

Para leer los elementos de un conjunto, añade . y el nombre del conjunto al comando.

  node.a[amenity=foo];

devolverá todos los nodos en el conjunto con nombre a que tienen la clave amenity con el valor foo.

Estructura del lenguaje

Existen varios tipos de declaraciones de Overpass QL. Se agrupan en:

  • Ajustes, que son variables globales opcionales, establecidas en la primera declaración de la consulta. Ejemplos de ajustes son el tiempo de espera del servidor de la API de Overpass y el formato de salida de la consulta Overpass QL.
  • Declaraciones de bloqueo: Las declaraciones de bloqueo agrupan declaraciones de Overpass QL para posibilitar disyunciones (pruebas de verdad), así como bucles.
  • Consultas independientes: Estas son declaraciones completas por sí mismas. Pueden realizar funciones como consultar el servidor de la API de Overpass para crear un conjunto, manipular el contenido de un conjunto existente o enviar los resultados finales de una consulta a una ubicación de salida.

Las consultas autónomas están a su vez compuestas por componentes más pequeños del lenguaje Overpass QL, como evaluadores, filtros y operadores.

Paréntesis

La sintaxis QL usa paréntesis (), corchetes [] y llaves {}. En esta página de documentación se distingue entre los tres tipos. Véase también Paréntesis para conocer detalles de esta nomenclatura.

Ajustes

Los ajustes de Overpass QL se deben declarar en la primera declaración del código fuente de Overpass QL sin contar los comentarios. Los ajustes no pueden ser declarados en varias declaraciones.

Las declaraciones de ajustes se incluyen entre corchetes []. Un signo de dos puntos : aparece entre el nombre del ajuste y el valor o valores a establecer. La declaración de ajustes debe terminar con un signo de punto y coma ;.

// Esta es una línea típica de declaración de ajustes
// en un servidor de Overpass Turbo
[out:json][timeout:25];

Tiempo de consulta (timeout:)

El ajuste timeout: tiene un parámetro, un entero no negativo. El valor predeterminado es 180.

Este parámetro indica el máximo tiempo en segundos de ejecución permitido para la consulta, tal como lo espera el usuario. Si la consulta se ejecuta durante más tiempo que este, el servidor puede abortar la consulta por tiempo de espera. El segundo efecto es que cuanto más alto sea este valor, más probable es que el servidor rechace la consulta antes de ejecutarla.

Así que, si envías una gran consulta realmente compleja, ponle el prefijo de un valor más alto; p. ej., «3600» para una hora. Y asegúrate de que tu cliente sea lo suficientemente paciente para no abortar debido al tiempo de espera en sí mismo.

Ejemplo:

  [timeout:180]

Límite del elemento (maxsize:)

El ajuste maxsize: tiene un parámetro, un entero no negativo. El valor predeterminado es 536870912 (512 MB).

Este parámetro indica el máximo de memoria permitido para la consulta en bytes de RAM en el servidor, tal como lo espera el usuario. Si la consulta necesita más RAM que este valor, el servidor puede abortar la consulta por un agotamiento de la memoria. El segundo efecto es que cuanto más alto sea este valor, más probable es que el servidor rechace la consulta antes de ejecutarla.

Así que, si envías una gran consulta realmente compleja, ponle el prefijo de un valor más alto; p. ej., «1073741824» para un gigabyte. El valor máximo depende en gran medida de la carga actual del servidor, p. ej., las solicitudes de 2 GB probablemente serán rechazadas durante las horas punta, ya que no encajan en la gestión global de recursos. Técnicamente hablando, el tamaño máximo se trata como un número señalado de 64 bits.

Ejemplo:

  [maxsize:1073741824]

Nota importante: Recientemente, se introdujo un nuevo mecanismo para abortar las consultas que excedan los 2 GB de memoria. El tamaño exacto de este límite todavía está en discusión y podría cambiar con el tiempo. Si experimentas mensajes de error como «runtime error Query run out of memory using about 2048 MB of RAM.» (en español: «error de ejecución: La consulta se ha quedado sin memoria usando unos 2048 MB de RAM.»), asegúrate de leer también este hilo.

Formato de salida (out:)

El ajuste global out: no está relacionado con la declaración out. La sintaxis no debe mezclarse.

El ajuste out define el formato de salida usado para ofrecer los datos de OSM. Puede tomar uno de cinco valores; el valor predeterminado es xml:

  • xml
  • json (no confundir con geoJSON)
  • csv
  • custom
  • popup

Ejemplo:

  [out:json]

Modo de salida CSV

El formato de salida CSV ofrece los datos de OSM como un documento csv, que puede abrirse directamente en herramientas como LibreOffice. Requiere parámetros de configuración adicionales para definir una lista de campos a mostrar, así como dos parámetros opcionales para añadir la eliminación de la línea de encabezamiento CSV y el cambio del separador de columna.

Formato:

  [out:csv( fieldname_1 [,fieldname_n ...] [; csv-headerline [; csv-separator-character ] ] )]

Notas:

  • Los valores numéricos (coordenadas, identificadores) no usan separador de miles y usan el punto inglés (.) para el separador decimal (en coordenadas geométricas).
  • No se hace ninguna escapatoria para los caracteres específicos en valores de la cadena. Esto cambiará con la versión 0.7.55.
  • El carácter separador predeterminado (tabulador) debería permitir la mayor parte del tiempo analizar los datos tabulares sin que falten, se rompan o se desajusten las columnas.
  • Estos valores predeterminados de CSV pueden no coincidir con lo que espera la aplicación de la hoja de cálculo (en particular, el separador decimal en las versiones no inglesas) si abres el archivo CSV directamente con tu aplicación, y los datos podrían aparecer como corruptos o imposibles de analizar: en su lugar, importa los datos en una columna de solo texto en una nueva hoja de cálculo y conviértelos en datos tabulares dentro de esa aplicación utilizando tu propia configuración; o usa una secuencia de comandos o script de filtro externo para convertir el archivo antes de abrirlo.
Ejemplo sencillo

[out:csv(name)] solo dará como resultado una etiqueta con el nombre. Véase más abajo para ejemplos más complicados.

Lista de nombres de campos

Además de los nombres de campo normales de OSM (etiquetas), hay disponibles campos especiales para cada elemento del conjunto de resultados que se va a generar. Nótese que todos estos nombres de campo especiales deben ir precedidos de dos signos de dos puntos ::.

Nombre de campo especial Descripción
::id Identificador del objeto OSM
::type Tipo de objeto OSM: nodo, vía, relación
::otype Objeto OSM como valor numérico
::lat Latitud (disponible para nodos o en modo out center)
::lon Longitud (disponible para nodos o en modo out center)
Los siguientes campos de metainformación están solo disponibles si se usa out meta; para dar salida a los elementos OSM.
::version El número de versión del objeto OSM
::timestamp Marca de tiempo del último cambio de un objeto OSM
::changeset Conjunto de cambios en el que el objeto fue cambiado
::uid Identificador de usuario OSM
::user Nombre de usuario OSM
Los siguientes campos de metainformación están solo disponibles si se usa out meta; para dar salida a los elementos OSM.
::count Da como resultado el número total de objetos (nodos, vías, relaciones y áreas) en el conjunto de entrada
::count:nodes Da como resultado el número de nodos en el conjunto de entrada
::count:ways Da como resultado el número de vías en el conjunto de entrada
::count:relations Da como resultado el número de relaciones en el conjunto de entrada
::count:areas Da como resultado el número de áreas en el conjunto de entrada

Ejemplo:

  [out:csv(
    ::"id", amenity, name, operator, opening_hours, "contact:website", "contact:phone", brand, dispensing, lastcheck
  )];

Estaciones de ferrocarril en Bonn:

try it yourself in overpass-turbo
[out:csv(::id,::type,"name")];
area[name="Bonn"];
nwr(area)[railway=station];
out;
Línea de encabezamiento CSV

La presencia o ausencia de una línea de encabezamiento puede ser controlada mediante el primer parámetro opcional, que puede añadirse justo después de la lista de campos separado con un signo de punto y coma. Los valores posibles incluyen true y false. El valor predeterminado es true.

  [out:csv(
    ::"id", amenity, name, operator, opening_hours, "contact:website", "contact:phone", brand, dispensing, lastcheck;
    false
  )];
Carácter separador CSV

De forma predeterminada, todos los campos se separan con un carácter de tabulador ("\t"). No obstante, este ajuste se puede cambiar a través del segundo parámetro opcional. En el siguiente ejemplo, todos los campos de salida serán separados con un carácter de barra vertical ("|") en lugar de con un carácter de tabulador.

  [out:csv(
    ::"id", amenity, name, operator, opening_hours, "contact:website", "contact:phone", brand, dispensing, lastcheck;
    true; "|"
  )];
Comprobando la salida del CSV para obtener datos completos

A diferencia de otros modos de salida como XML y JSON, actualmente no se ofrece ninguna indicación de mensaje de error si fuese ese el caso. Un resultado vacío (o un resultado con solo una línea de encabezamiento) podría indicar que no se encontró nada o que la consulta fue abortada debido al tiempo de espera o a alguna otra condición de error más grave. Una forma de evitarlo es introducir un contador adicional que resuma el resultado de la consulta anterior, y que siempre se coloca como la última declaración de salida de una consulta.

El siguiente ejemplo amplía la lista anteriormente mostrada de todas las estaciones de ferrocarril de Bonn mediante una declaración de salida adicional que devuelve una fila agregada adicional en el CSV, describiendo un seudoelemento con el tipo «count» y cuyo valor estará en la última columna solicitada ::count (cuyo valor permanece vacío para las filas de datos normales):

  [out:csv(::type,::id,"name",::count)];
  area[name="Bonn"]->.a;
  ( node(area.a)[railway=station];
    way(area.a)[railway=station];
    rel(area.a)[railway=station];
  );
  out;
  out count;

Los resultados ahora incluyen una columna adicional con el tipo ::count y una indicación de cuántos elementos totales están contenidos en el conjunto de resultados actual: 5. Si falta la línea de recuento final o el número total difiere, se sabe con certeza que algo salió mal y los resultados de la consulta están incompletos o son inconsistentes.

@type	@id	name	@count
node	26945519	Bonn-Oberkassel	
node	1271017705	Bonn-Beuel	
node	2428355974	Bonn-Bad Godesberg	
node	2713060210	Bonn Hauptbahnhof	
node	3400717493	Bonn-Mehlem	
count	0		5

Los valores custom y popup también requieren ajustes de configuración adicionales. Por favor, consulta los detalles en la documentación de formatos de salida.

Recuadro delimitador global (bbox)

El 'recuadro delimitador' define el área del mapa que incluye la consulta. El ajuste recuadro delimitador global se puede usar para definir un recuadro delimitador y que este se emplee luego implícitamente en todas las declaraciones (a menos que una declaración especifique un recuadro delimitador explícito diferente). Si no se especifica un bbox, el valor predeterminado es «el mundo entero».

En un programa estándar Overpass QL, se construye un recuadro delimitador con dos pares de coordenadas de grados decimales en formato y orden estándares ISO 6709, y cada valor se separa con una coma. Los valores son, en orden: latitud máxima meridional, longitud máxima occidental, latitud máxima septentrional, longitud máxima oriental.

[bbox:south,west,north,east]
// Un bbox enmarcando la ciudad alemana de Bonn
[bbox:50.6,7.0,50.8,7.3]
// Un bbox enmarcando parte de Río de Janeiro, Brasil
[bbox:-23,-43.3,-22.8,-43.1]

Nota: Cuando una consulta se codifica como el valor del parámetro data=, también se puede añadir un recuadro delimitador como una variable separada bbox. Cuando se usa de esta manera, el orden se invierte, lon-lat (este es el orden común para OpenLayers y otros entornos de trabajo).

El ejemplo de Bonn anterior empleando una codificación URL:

  /api/interpreter?data=[bbox];node[amenity=post_box];out;&bbox=7.0,50.6,7.3,50.8

Esto encontraría todos los buzones de correo que se ubican aproximadamente en Bonn, Alemania.

Fecha (date)

date es un ajuste global que modifica una consulta Overpass QL para examinar datos attic y ofrecer resultados basados en la base de datos de OpenStreetMap a partir de la fecha especificada. Este ajuste puede resultar útil, por ejemplo, para reconstruir datos que han sido vandalizados, o simplemente para ver un objeto como existió en la base de datos en algún punto del pasado.

Consiste en un identificador date seguido de : y luego una fecha según el estándar ISO 8601 de la base de datos de OpenStreetMap entre comillas, en formato YYYY-MM-DDThh:mm:ssZ.

Este ejemplo consulta el estado de la base de datos el 28 de octubre de 2015 a las 19:20:00 UTC:

[date:"2015-10-28T19:20:00Z"]

No hay datos attic en la base de datos de OpenStreetMap con una fecha anterior a 2012-09-12T06:55:00Z (1347432900 en segundos de duración). Esta fecha corresponde al primer cambio incluido en el archivo planet compatible con la ODbL. Usar una date anterior es técnicamente posible, pero al hacerlo siempre devolverá el estado de la base de datos a partir de 2012-09-12T06:55:00Z.

Diferencia entre dos fechas (diff)

El ajuste diff permite a la base de datos determinar la diferencia de dos consultas en diferentes momentos. Esto es útil, por ejemplo, para ver las diferencias entre dos extractos de la base de datos.

Consiste en el identificador diff seguido de :, una fecha según el estándar ISO 8601 entre comillas, en formato YYYY-MM-DDThh:mm:ssZ y, opcionalmente, una coma y una segunda fecha, que será la fecha actual («now») si no se especifica otra.

Ejemplo:

[diff:"2012-09-14T15:00:00Z"]

Esto procesa el resto de la consulta como si se hubiera planteado el 14 de septiembre de 2012 a las 15:00, luego procesa la misma consulta con los datos actuales y finalmente genera la diferencia entre los dos resultados.

[diff:"2012-09-14T15:00:00Z","2012-09-21T15:00:00Z"]

Esto hace básicamente lo mismo, pero compara el estado del 14 de septiembre con el del 21 de septiembre.

Ten en cuenta que el resultado no incluye ninguna versión intermedia, que podría existir entre la primera y la última marca de tiempo: es decir, si hay varios cambios en un objeto, solo se dará como resultado la última versión en el marco temporal especificado.

Diferencia aumentada entre dos fechas (adiff)

El ajuste adiff hace básicamente lo mismo que diff, pero indicando lo que les sucedió a todos los elementos que no están contenidos en el resultado más reciente.

Si un elemento ha sido borrado, entonces se imprimirá su última fecha de borrado y la indicación «visible=false». Si un elemento ha cambiado de tal manera que ya no coincide con la consulta, entonces se imprimirá su última fecha de cambio y la indicación «visible=true».

Para más información, véase Diffs aumentados.

Declaraciones en bloque

Unión

La declaración en bloque de unión se escribe como una pareja de paréntesis. Dentro de la unión, se puede colocar cualquier secuencia de declaraciones, incluyendo declaraciones anidadas de unión y foreach. Ten en cuenta que los corchetes [ ... ] que aparecen a continuación indican una parte opcional de la sintaxis y no deben ser introducidos literalmente.

  (declaración_1; declaración_2; )[->.conjunto_resultado];

La declaración en bloque de unión no necesita ningún conjunto de entrada. Produce un conjunto de resultados que es la unión de los conjuntos de resultados de todas las subdeclaraciones, independientemente de si una subdeclaración tiene un conjunto de resultados redirigido o no.

Ejemplo:

  (node[name="Foo"]; way[name="Foo"];);

La primera declaración recoge todos los nodos que tienen una etiqueta name de valor «Foo»; la segunda declaración recoge todas las vías que tienen una etiqueta name de valor «Foo». Después de la declaración de unión, el conjunto de resultados es la unión de los conjuntos de resultados de ambas declaraciones.

El conjunto de resultados de la declaración de la unión puede ser redirigido con la notación posfija habitual.

Ejemplo:

  (node[name="Foo"]; way[name="Foo"];)->.a;

Es lo mismo que el ejemplo anterior, pero el resultado se escribe en la variable a.

Limitación: Ten en cuenta que las declaraciones foreach y print no pueden ser subelementos del elemento unión.

Diferencia

La declaración en bloque de diferencia se escribe con un par de paréntesis. Dentro de la declaración de diferencia, se debe colocar únicamente dos declaraciones, separadas por un signo menos. Nótese que los corchetes [ ... ] que se muestran a continuación indican una parte opcional de la sintaxis y no deben ser introducidos literalmente.

  (declaración_1; - declaración_2;)[->.conjunto_resultado];

La declaración en bloque de diferencia no necesita conjunto de entrada. Produce un conjunto de resultados que contiene todos los elementos que son resultado de la primera subdeclaración y que no están contenidos en el resultado de la segunda subdeclaración.

Ejemplo:

  (node[name="Foo"]; - node(50.0,7.0,51.0,8.0););

Esto recopila todos los nodos que tienen una etiqueta con el nombre «Foo» pero que no están dentro del recuadro delimitador indicado.

El conjunto de resultados de la declaración de diferencia puede ser redirigido con la notación posfija habitual.

Ejemplo:

  (node[name="Foo"]; - node(50.0,7.0,51.0,8.0);)->.a;

Es lo mismo que el ejemplo anterior, pero el resultado se escribe en la variable a.

Intersección

También es posible generar un conjunto de elementos que aparezcan en ambos conjuntos de entrada, es decir, elementos que forman parte de ambos conjuntos. Esto se describe más adelante en Por conjunto de entrada (.setname):

  node.a.b;

Esta no es una declaración en bloque, pero se introduce aquí por su estrecha relación con la declaración de diferencia descrita anteriormente.

Declaración en bloque if

a partir de v0.7.55

La declaración en bloque if ejecuta sus subdeclaraciones solo si su condición se evalúa como verdad booleana. Esto permite, por ejemplo, probar condiciones de búsqueda más flexibles si las condiciones de búsqueda más estrictas no dan resultado.

La declaración no interactúa directamente con ningún conjunto.

La sintaxis básica es

 if (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }

o bien

 if (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }
 else
 {
   <Lista de subdeclaraciones>
 }

donde <Evaluador> es el evaluador y <Lista de subdeclaraciones> es una lista de subdeclaraciones.

Bucle para-cada (foreach)

a partir de v0.7.51

La declaración en bloque foreach se escribe con la palabra clave foreach seguida de un par de signos de llaves. Cualquier secuencia de declaraciones puede ser colocada entre estas llaves, incluso uniones y declaraciones foreach.

La declaración de bloque foreach toma un conjunto de entrada y no produce ningún conjunto de resultados. La declaración foreach se repite en el contenido del conjunto de entrada, una vez por cada elemento del conjunto de entrada.

Ejemplo:

  way[name="Foo"];
  foreach
  {
    (
      ._;
      >;
    );
    out;
  }

Por cada vía que tenga una etiqueta con el valor «Foo», esto imprime los nodos que pertenecen a esas vías inmediatamente seguidos por la propia vía. En detalle, el conjunto de resultados de way[name="Foo"] se toma como el conjunto de entrada. Luego, para cada elemento de este conjunto de entrada, el cuerpo del bucle se ejecuta una vez. Dentro del cuerpo del bucle, se toma la unión del elemento y sus nodos. Finalmente, esta unión se imprime.

Nótese que durante la ejecución, cada subconjunto impreso en una iteración es independiente de los subconjuntos impresos en otras iteraciones, lo que puede dar lugar a objetos duplicados en la salida global (no se calcula ninguna unión mediante la declaración out dentro del bucle).

El conjunto de entrada de la declaración foreach puede ser tomado de una variable con la notación posfija habitual:

Ejemplo:

  foreach.a(...);

Esto hace un bucle sobre el contenido del conjunto a en lugar del conjunto predeterminado «_».

El nombre de la variable en la que se pone el elemento de bucle también puede elegirse añadiendo una anotación posfija inmediatamente antes del paréntesis de apertura.

Ejemplo:

  foreach->.b(...);

Esto pone el elemento a hacer bucle en la variable b. Sin ella, la declaración foreach no pone los elementos en ningún conjunto.

Ejemplo donde conjunto de entrada y bucle se han cambiado:

  foreach.a->.b(...);

Ten en cuenta que el conjunto de entrada no puede ser alterado por el bucle. Cualquier actualización del conjunto se guardará para su uso posterior, pero esto no alterará el número de iteraciones.

Declaración en bloque for

a partir de v0.7.55

La declaración en bloque for divide su entrada en subconjuntos y ejecuta todas las declaraciones en el cuerpo del bucle una vez por cada subconjunto.

El conjunto de entradas se desglosa de la siguiente manera: para cada elemento se evalúa el evaluador especificado y los elementos con el mismo valor se agrupan; al principio de cada ejecución del bucle, el conjunto de salida se rellena con el subconjunto correspondiente.

La sintaxis básica es

 for (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }

El conjunto de entrada y salida puede especificarse entre for y el paréntesis de apertura, es decir, tú estableces el conjunto de entrada

 for.<Nombre del conjunto de entrada> (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }

o el conjunto de salida

 for->.<Nombre del conjunto de salida> (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }

o ambos

 for.<Nombre del conjunto de entrada>->.<Nombre del conjunto de salida> (<Evaluador>)
 {
   <Lista de subdeclaraciones>
 }

Dentro del bucle, el valor del evaluador está disponible a través de la propiedad val del conjunto de salida. Es decir, con

 <Conjunto de salida>.val

puedes acceder al valor de la expresión para este bucle.

Con el evaluador especial keys(), se puede hacer un bucle sobre todas las claves que existen en el subconjunto. El subconjunto respectivo de cada clave son los elementos que tienen este conjunto de claves. A diferencia de un evaluador habitual, los conjuntos no son mutuamente distintos en ese caso.

Declaración en bloque complete

a partir de v0.7.55

La declaración de bloque complete hace un bucle a través de sus subdeclaraciones hasta que los resultados del bucle se estabilicen. Esto permite rastrear un grupo de elementos sueltos o estrechamente conectados, como todos los tramos de un vial con el mismo nombre o un sistema de ríos tributarios.

La declaración entrega los elementos acumulados en su conjunto de salida tanto al principio de cada ejecución del bucle como en la salida de toda la declaración.

Los elementos se acumulan del conjunto de entrada antes de entrar en el bucle y de nuevo desde el conjunto de entrada al final del bucle.

Si el conjunto de entrada contiene elementos adicionales, entonces el bucle se ejecuta de nuevo.

La sintaxis básica es

 complete
 {
   <Lista de subdeclaraciones>
 }

donde <Lista de subdeclaraciones> es una lista de subdeclaraciones.

El número máximo de bucles está predeterminado en 4096 bucles. Este valor puede cambiarse a cualquier valor entre 1 y 1048576 para este bucle. Para ello, pon el valor deseado entre paréntesis después de la palabra clave «complete»:

 complete(<Número>)
 {
   <Lista de subdeclaraciones>
 }

Los conjuntos de entrada y salida pueden especificarse entre la palabra clave «complete» y la llave de apertura, es decir, tú estableces el conjunto de entrada

 complete.<Nombre del conjunto de entrada>
 {
   <Lista de subdeclaraciones>
 }

o el conjunto de salida

 complete->.<Nombre del conjunto de salida>
 {
   <Lista de subdeclaraciones>
 }

o ambos

 complete.<Nombre del conjunto de entrada>->.<Nombre del conjunto de salida>
 {
   <Lista de subdeclaraciones>
 }

o bien

 complete(<Número>).<Nombre del conjunto de entrada>->.<Nombre del conjunto de salida>
 {
   <Lista de subdeclaraciones>
 }

Declaración en bloque retro

a partir de v0.7.55

La declaración en bloque retro ejecuta sus subdeclaraciones para la fecha especificada en el evaluador.

Actualmente no está definido si el contenido de las variables fuera del bloque están disponibles dentro del bloque y viceversa. Las versiones futuras podrán transferir solo elementos derivados, mantener los entornos completamente separados o transformar elementos de un punto en el tiempo a otro.

La sintaxis básica es

retro (<Evaluador>)
{
  <Lista de subdeclaraciones>
}

donde <Evaluador> es un evaluador y <Lista de subdeclaraciones> es una lista de subdeclaraciones.

Declaración en bloque compare

a partir de v0.7.55

La declaración compare calcula la diferencia de los datos de dos marcas de tiempo. Esa diferencia puede consistir en cualquier elemento, así como solo en aquellos con propiedades específicas.

La declaración puede tener un bloque de subdeclaraciones. El bloque de subdeclaraciones se ejecuta después de calcular el diff en la segunda ejecución, una vez para la antigua marca de tiempo y luego otra vez para la nueva marca de tiempo. Esto permite hacer cálculos adicionales basados en los resultados del diff.

La declaración solo se puede usar en modo diff. En otros modos su comportamiento es indefinido, y en futuras versiones podría ser un error de sintaxis tenerla en otro lugar.

En la primera ejecución de una consulta diff devuelve un conjunto vacío. En la segunda ejecución de una consulta diff devuelve la diferencia de los elementos. Si la declaración obtiene un evaluador como argumento, entonces solo se devuelven los elementos que tienen valores diferentes en ambas marcas de tiempo. Si el elemento no existe en una de las marcas de tiempo, entonces su valor se considera como una cadena vacía. Actualmente, el único propósito de tal diferencia es introducirla en una declaración de salida.

La sintaxis base es

 compare();

Además, se puede especificar un conjunto de entrada o de salida

 .<Conjunto> compare()->.<Conjunto>;

Con el evaluador, la sintaxis sería

 compare(delta:<Evaluador>);

o bien

 .<Conjunto> compare->.<Conjunto>(delta:<Evaluador>);

En todas las variantes de sintaxis se puede adjuntar un bloque de subdeclaraciones:

 compare()
 {
   <Lista de subdeclaraciones>
 };

O bien

 .<Conjunto> compare(delta:<Evaluador>)->.<Conjunto>;
 {
   <Lista de subdeclaraciones>
 };

Consultas independientes

Salida (out)

La declaración out no está relacionada con el ajuste global out:. No se deben mezclar las sintaxis.

La declaración out da como resultado el contenido de un conjunto. Se usa casi siempre en cualquier consulta de Overpass QL.

out count; es una declaración que imprime solo el recuento total de elementos por tipo (nodos, vías, relaciones, áreas) en el conjunto de entrada. No se puede combinar con nada más.

La forma más simple de la declaración out tiene varios predeterminados implícitos

out;         // La forma más simple de la declaración «out»
._ out body; // Idéntico significado al anterior

El conjunto de entrada predeterminado _ puede ser anulado precediendo con un punto y un nombre de conjunto la declaración out.

.miscosas out; // Da como resultado el conjunto llamado 'miscosas'

La declaración out puede ser configurada con un número arbitrario de parámetros que se añaden, separados por espacios en blanco, entre la palabra out y el punto y coma.

Los valores permitidos, en cualquier orden, son:

  • Uno de los siguientes para el grado de detalle de la salida; el valor predeterminado es body:
    • ids: Imprime solo los identificadores (ids) de los elementos en el conjunto.
    • skel: Imprime la información mínima necesaria para la geometría.
      • para nodes: identificador (id) y coordenadas
      • para ways: identificador y los identificadores de sus nodos miembro
      • para relations: identificador de la relación y el identificador, tipo y rol de todos sus miembros.
    • body: Imprime toda la información necesaria para usar los datos. Esto incluye las etiquetas para todos los elementos y los roles de los miembros de la relación.
    • tags: Imprime solo los identificadores y etiquetas para cada elemento y no las coordenadas ni los miembros.
    • meta: Imprime todo lo que se sabe sobre los elementos. Los meta incluyen todo lo que sale para body para cada elemento OSM, así como la versión, identificador del conjunto de cambios, la marca de tiempo y datos del usuario que tocó el objeto por última vez. Los atributos de metadatos de los elementos derivados también faltan para los elementos derivados. El modificador noids permite omitir todos los identificadores en la declaración.
  • Uno de los siguientes modificadores para la información geolocalizada; lo predeterminado es no imprimir ninguno:
    • geom: Añade la geometría completa a cada objeto. Esto añade coordenadas a cada nodo, a cada miembro del nodo de una vía o relación, y añade una secuencia de miembros «nd» con coordenadas a todas las relaciones.
    • bb: Añade solo el recuadro delimitador de cada elemento al elemento. Para los nodos esto equivale a «geom». Para las vías es el recuadro delimitador de todos los nodos. Para las relaciones es el recuadro delimitador de todos miembros tipo nodo y tipo vía; sobre las relaciones como miembros no tiene efecto.
    • center: Esto solo añade el centro del recuadro delimitador mencionado anteriormente a las vías y relaciones. Nota: No se garantiza que el punto central esté dentro del polígono (ejemplo).
  • Un recuadro delimitador en el formato «(sur, oeste, norte, este)» (normalmente se usa con el tipo de detalle geom). En este caso, solo se obtienen elementos cuyas coordenadas están dentro de este recuadro delimitador. En el caso de los segmentos de vías, también se obtienen las primeras o últimas coordenadas fuera de este recuadro delimitador para permitir que los segmentos se formen adecuadamente (esta restricción no tiene efecto sobre los elementos derivados sin ninguna geometría).
  • Se puede añadir una de las siguientes opciones para indicar orden de clasificación. La opción predeterminada es asc:
    • asc: Ordena por el identificador del objeto.
    • qt: Ordena por el índice cuadrátil; esto es aproximadamente geográfico y significativamente más rápido que el orden por idenficadores (los elementos derivados generados por declaraciones make o convert sin ninguna geometría se agruparán por separado, ordenados únicamente por identificador).
  • Un número entero no negativo, que limita la salida a un máximo del número especificado. Si no se especifica, se ofrecerá como resultado el conjunto completo.

Elemento

La consulta independiente de elemento consiste únicamente de un prefijo de conjunto de entrada.

Toma el conjunto de entrada especificado por su prefijo. Esto es particularmente útil para las declaraciones de unión: reproduce su conjunto de entrada como (parte del) resultado de la declaración de unión.

El uso más común es cuando se usa con el conjunto de entrada predeterminado, _, como se muestra a continuación.

  ._;

La siguiente declaración de unión unirá todos los elementos del conjunto de entrada predeterminado con el resultado de la recursividad hacia abajo del conjunto de entrada predeterminado. Luego, devolverá el resultado al conjunto de entrada predeterminado, sobrescribiéndolo.

  (._; >;);

Pero, por supuesto, otros conjuntos también son posibles:

  .a;

En el contexto de una declaración de unión:

  (.a; .a >;);

Nota: Las declaraciones posteriores en una declaración de unión no se ven afectadas por la declaración de elemento. En particular, .a; no añade el contenido del conjunto de entrada a _, el conjunto de elementos predeterminado.

La declaración de elemento también puede utilizarse como filtro.

Recursividad hacia arriba (<)

La consulta independiente de recursividad hacia arriba se escribe con un único signo menos qué, <.

Necesita un conjunto de entrada y produce un conjunto de resultados. Su conjunto de resultados está compuesto por:

  • todas las vías que tengan un nodo que aparezca en el conjunto de entrada, más
  • todas las relaciones que tengan un nodo o vía que aparezca en el conjunto entrada; más
  • todas las relaciones que tengan una vía que aparezca en el conjunto de resultados.

Ejemplo:

  <;

El conjunto de entrada de la declaración de recursividad hacia arriba se puede elegir con la notación prefija habitual:

  .a <;

El conjunto de resultados de una declaración de recursividad hacia arriba se puede redirigir con la notación prefija habitual:

  < ->.b;

Por supuesto, puedes cambiar ambos conjuntos a la vez:

  .a < ->.b;

Recursividad de relaciones hacia arriba (<<)

La declaración autónoma de recursividad de relaciones hacia arriba tiene una sintaxis similar a la declaración de recursividad hacia arriba, pero se escribe con un doble signo menor qué, <<.

En concreto, puedes cambiar el conjunto de entrada o de resultados con la misma notación que se usa para la consulta independiente de recursividad hacia arriba.

Además de los resultados de la recursividad hacia arriba, la declaración sigue los vínculos subsiguientes en las relaciones encontradas hasta abarcar todas las relaciones que apuntan a un objeto en el conjunto de entrada o resultados.

Precisamente, la consulta independiente de recursividad de relaciones hacia arriba devuelve el cierre transitivo y reflexivo de la membresía hacia atrás.

Cuidado: Hecho sobre un nodo o una vía, devolverá los padres de ese nodo [1] o esa vía[2] (como se esperaba). Hecho sobre una relación, devolverá tanto la relación en sí misma como sus relaciones padre[3]. Si solo quieres las relaciones padre, puedes usar: (<<; - rel._;); en su lugar[4].

Sintaxis:

  <<;

Recursividad hacia abajo (>)

La consulta independiente de recursividad hacia abajo se escribe con un único signo mayor qué, >.

Necesita un conjunto de entrada y produce un conjunto de resultados. Su conjunto de resultados está compuesto por:

  • todos los nodos que formen parte de una vía que aparezca en el conjunto de entrada; más
  • todos los nodos y vías que sean miembros de una relación que aparezca en el conjunto de entrada; más
  • todos los nodos que sean parte de una vía que aparezca en el conjunto de resultados

En concreto, puedes cambiar la entrada o el conjunto de resultados con la misma anotación que para la consulta independiente recursividad hacia arriba.

Ejemplo:

  >;

Recursividad de relaciones hacia abajo (>>)

La declaración de recursividad de relaciones hacia abajo tiene una sintaxis similar a la declaración de recursividad hacia abajo, pero se escribe con un signo doble mayor qué.

En concreto, puedes cambiar la entrada o el conjunto de resultados con la misma anotación que para la consulta independiente de recursividad hacia abajo.

La declaración sigue los vínculos de pertenencia, incluyendo nodos de vías, hasta que todos los miembros del conjunto de entrada o de resultados para cada objeto de ese conjunto están también en el conjunto de resultados.

Precisamente, la declaración de recursividad de relaciones hacia abajo devuelve el cierre transitivo y reflexivo de la membresía.

Sintaxis:

  >>;

Consulta por área (is_in)

La consulta independiente is_in devuelve las áreas que cubren

  • las coordenadas especificadas (cuando se especifican coordenadas) o
  • uno o más nodos del conjunto de entrada (cuando no se especifican coordenadas).

Toma un conjunto de entrada o una coordenada y produce un conjunto de resultados. Los resultados son todas las áreas que contienen al menos un nodo del conjunto de entrada o las coordenadas especificadas.

is_in no se puede usar directamente con ninguno de los filtros de Overpass QL. Para filtrar el resultado de is_in es necesario realizar otra consulta (véase más adelante: los [corchetes] que se muestran a continuación, indican las partes opcionales y no forman parte de la sintaxis a escribir.

  [.conjunto_entrada] is_in         [-> .conjunto_resultado];
  is_in(latitud, longitud) [-> .conjunto_resultado];

En su forma más corta, toma su conjunto de entrada como las coordenadas a buscar. Ejemplo:

  is_in;

El conjunto de entrada se puede elegir con la notación prefija habitual:

  .a is_in;

El conjunto de resultados puede ser redirigido con la notación posfijahabitual:

  is_in->.b;

Por supuesto, puedes también cambiar ambos a la vez:

  .a is_in->.b;

En lugar de tomar los nodos existentes, también puedes especificar las coordenadas con dos números de punto flotante, separados por una coma. Se interpretan como latitud, longitud. En este caso, el conjunto de entrada es ignorado. Ejemplo:

  is_in(50.7,7.2);

También en esta variante, el conjunto de resultados puede ser redirigido con la notación posfija habitual:

  is_in(50.7,7.2)->.b;

La creación del área depende de algunas reglas de extracción específicas, ¡no hay una contraparte del área para todas y cada una de las vías o relaciones de OSM! Para más detalles, véase areas.osm3s y la página wiki Áreas.

Para filtrar el resultado devuelto por is_in por criterios de filtro adicionales, se necesita una consulta adicional:

  is_in(48.856089,2.29789);
  area._[admin_level="2"];     // ._ representa el conjunto de entrada predeterminado, que contiene todas las áreas devueltas por ''is_in''.

Declaración timeline

a partir de v0.7.55

La declaración timeline toma como argumentos el tipo e identificar de un objeto y, opcionalmente, la versión. Luego devuelve una estructura derivada que contiene la metainformación de la versión especificada. Si no se especifica ninguna versión, entonces se devuelve un objeto por cada versión conocida. Cada uno de estos objetos tiene las etiquetas ref, reftype y refversion para identificar la referencia. Además, tiene las etiquetas created y expired que contienen las marcas de tiempo relevantes.

La sintaxis básica es

 timeline(<Tipo>, <Referencia>);

o bien

 timeline(<Tipo>, <Referencia>, <Versión>);

donde <Tipo> es uno de los tres tipos literales, es decir, node, way o relation.

Además, se puede especificar el conjunto de salida <Conjunto>:

 timeline(<Tipo>, <Referencia>)->.<Conjunto>;

O bien

 timeline(<Tipo>, <Referencia>, <Versión>)->.<Conjunto>;

Declaración local

a partir de v0.7.55

La declaración local convierte la entrada especificada en la representación localizada de los datos de OSM. El parámetro de salida controla qué clase de datos se incluyen.

Sin un parámetro de tipo local, devuelve la geometría y las etiquetas. Esto equivale a un objeto por cada nodo etiquetado, más un objeto por cada parte de una vía, más un objeto por cada parte de una geometría de relación.

Con el parámetro de tipo «ll», devuelve adicionalmente objetos sueltos. Esto equivale a un objeto por vía con etiquetas, pero sin miembros de tipo nodo, y un objeto por miembro de relación de cualquier relación, sin miembros de tipo nodo o vía.

Con el parámetro de tipo «llb», devuelve aún más datos: entrega los objetos que asocian los identificadores de elementos OSM a los objetos mencionados.

La sintaxis básica es

 local <Tipo>

donde <Tipo> es «ll» o «llb» o no se especifica. También puedes indicar otro conjunto de entrada o de salida distinto del conjunto predeterminado _:

 .<Conjunto> local <Tipo> ->.<Conjunto>

El primer conjunto es el conjunto de entrada, el segundo conjunto es el conjunto de salida.

Declaración convert

a partir de v0.7.54

La declaración convert produce por cada elemento de su conjunto de entrada un elemento derivado. El contenido de este elemento de salida está controlado por los parámetros de la declaración.

Es necesario establecer un tipo fijo como tipo para todos los elementos generados. Después de eso, se puede establecer un número arbitrario de etiquetas. Además, se puede especificar que se copien todas las claves del objeto originario. En este caso, también es posible suprimir selectivamente algunas etiquetas.

Por último, es posible establecer explícitamente los identificadores de los objetos generados. Si no se establece un identificador, se asigna un identificador único a partir de un contador ascendente global.

La sintaxis es

 convert <Tipo> <Lista de etiquetas>

donde <Lista de etiquetas> es una lista de elementos separados por comas, cada uno de los cuales debe ser uno de los siguientes

 <Clave> = <Evaluador>
 ::id = <Evaluador>
 :: = <Evaluador>
 !<Clave>

Declaración make

a partir de v0.7.54

La declaración make produce por ejecución un elemento derivado. El contenido de este elemento derivado se controla mediante los parámetros de la declaración.

Es necesario establecer un tipo fijo como tipo para el elemento generado. Después de eso, se puede establecer un número arbitrario de etiquetas.

A diferencia de la declaración convert, establecer una clave genérica requiere que se añada el nombre de un conjunto. En el momento de la ejecución, una declaración make con una clave genérica establece etiquetas para todas las claves que aparecen al menos una vez en cualquiera de los elementos del conjunto elegido. Las etiquetas definidas explícitamente siempre anulan las claves generadas por el mecanismo de la clave genérica. De manera similar, explícitamente con un shrek, las etiquetas canceladas son omitidas por el mecanismo de la clave genérica.

Finalmente, es posible establecer explícitamente el identificador del objeto generado. Si no se establece un identificador, entonces se asigna un identificador único a partir de un contador ascendente global.

La sintaxis básica es

 make <Tipo> <Lista de etiquetas>

donde <Lista de etiquetas> es una lita de elementos separados por comas, cada uno de los cuales debe ser uno de los siguientes

 <Clave> = <Evaluador>
 <Conjunto>:: = <Evaluador>
 !<Clave>
 ::id = <Evaluador>

Es un error de sintaxis establecer la misma clave dos veces. Además, como máximo se puede establecer solo una clave genérica.

Declaración de consulta

La declaración más importante es la declaración de consulta. Esta no es una sola declaración, sino que consiste en uno de los especificadores de tipo node, ways, relation (o su abreviatura rel), derived, area o nwr (abreviatura de «nodos, vías (ways) o relaciones») seguido de uno o más filtros. El conjunto de resultados es el conjunto de todos los elementos que coinciden con las condiciones de todos los filtros.

Ejemplo:

// un filtro
  node[name="Foo"];
  way[name="Foo"];
  rel[name="Foo"];
  nwr[name="Foo"];
  nw[name="Foo"];
  nr[name="Foo"];
  wr[name="Foo"];
  derived[name="Foo"];
  area[name="Foo"];

// muchos filtros
  node[name="Foo"][type="Bar"];

Aquí, node, way, rel, nwr, derived y area hacen referencia al tipo, [name="Foo"] o [type="Bar"] son los filtros, y el signo de punto y coma cierra la declaración.

La declaración de consulta tiene un conjunto de resultados que puede cambiarse con la notación posfija habitual.

  node[name="Foo"]->.a;

Los filtros individuales pueden tener además conjuntos de entrada que pueden ser cambiados en los filtros individuales. Por favor, véase esto en el filtro respectivo.

Filtro de consulta

El filtro de consulta puede añadirse como condición a una declaración de consulta. Tiene un evaluador como argumento y deja pasar solo aquellos elementos para los cuales la expresión devuelve un verdadero booleano.

Por el momento, el filtro de consulta no puede ser la única condición en una consulta. Esto se debe a razones de implementación y cambiará en futuras versiones.

Es técnicamente posible tener múltiples filtros de consulta en una sola consulta, pero no tiene sentido: Sus evaluadores pueden combinarse con una conjunción en un filtro de consulta única. Esto tiene la misma semántica y es más rápido.

Su sintaxis es

 (if: <Evaluador>)

El espacio en blanco es opcional.

Filtros

Por etiqueta (has-kv)

El filtro has-kv selecciona todos los elementos que tienen o no una etiqueta con un valor determinado. Soporta los tipos básicos de OSM (nodo, vía y relación), así como el tipo adicional de área.

No tiene ningún conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Todas las variantes consisten en un paréntesis de apertura, luego una cadena literal entre comillas simples o dobles. En este punto, las variantes difieren. Todas las variantes terminan con un paréntesis de cierre. Si el literal de la cadena consiste solo en letras, las comillas pueden ser omitidas.

Iguales (=, !=)

La variante más común selecciona todos los elementos en los que la etiqueta con la clave dada tiene un valor específico. Esta variante contiene después del literal de la clave un signo igual y otro literal que contiene el valor. Ejemplos, todos equivalentes:

  node[name=Foo];
  node[name='Foo'];
  node[name="Foo"];
  node['name'="Foo"];
  node["name"="Foo"];
  node["name"='Foo'];

Si tienes un dígito, espacio en blanco o lo que sea en el valor, necesitarás usar comillas simples o dobles:

  node[name="Foo Street"];
  node["name:fr"="Rue Feau"];

La búsqueda de valores vacíos no es posible usando el operador valor igual. Esto solo puede lograrse utilizando una expresión regular:

node[power=""];          // no soportado
node[power~"^$"];        // usa una expresión regular en su lugar

Asimismo, la consulta de valores de clave vacíos tampoco es posible usando este tipo de consulta de valores de clave y debe expresarse mediante expresiones regulares.

node[~"^$"~"."];         // encuentra nodos con la clave vacía ("") y cualquier valor

Nota: El asistente de Overpass Turbo dispone de algunos procedimiento lógicos internos para convertir automáticamente ""="" como corresponde.

Existe

La segunda variante selecciona todos los elementos que tienen una etiqueta con una determinada clave y un valor arbitrario. No contiene nada entre el literal de la clave y el corchete de cierre:

  node["name"];
  node['name'];
  node[name];

No existe

a partir de v0.7.53

Esta variante selecciona todos los elementos, que no tienen una etiqueta con una cierta clave y un valor arbitrario.

  node[!"name"];
  node[!'name'];
  node[!name];

En versiones anteriores, el filtro 'no existe' debía escribirse como node["name"!~".*"];.

Valor coincidente con la expresión regular (~, !~)

La tercera variante selecciona todos los elementos que tienen una etiqueta con una determinada clave y un valor que coincide con alguna expresión regular. Contiene después del literal de la clave un virgulilla (~), y luego un segundo literal para la expresión regular a buscar:

Declaración Explicación
node["name"~"^Foo$"]; Encuentra nodos donde la etiqueta name coincide exactamente con Foo - idéntico a node["name"="Foo"];
node["name"~"^Foo"]; Encuentra nodos donde el valor de la etiqueta name comienza con Foo
node["name"~"Foo$"]; Encuentra nodos donde el valor de la etiqueta name termina con Foo
node["name"~"Foo"]; Encuentra nodos donde la etiqueta name contiene la subcadena Foo en cualquier lugar del valor de la etiqueta
node["name"~".*"]; Encuentra nodos donde la etiqueta name coincide con cualquier cosa - idéntico a node["name"];
node["name"!~".*"]; Encuentra nodos sin etiqueta name; nodos sin nombre de clave - idéntico a node[!"name"];

Por favor, ten en cuenta que en QL necesitarás prestar atención al uso de las barras invertidas: ["name"~"^St\."] resulta en la expresión regular ^St. (que encontrará todos los nombres que comienzan con «St»), mientras que ["name"~"^St\\."] produce la expresión regular más probable que tiene el significado de St. (que encontrará todos los nombres que comiencen por «St.»). Esto se debe a las reglas de escape de C y no se aplica a la sintaxis XML.

Overpass implementa la sintaxis de expresiones regulares POSIX extendida en la Wikipedia.

Insensibilidad a mayúsculas/minúsculas

También puedes buscar indistintamente entre mayúsculas y minúsculas

  node["name"~"^Foo$",i];    /* encuentra «foo», «FOO», «fOo», «Foo», etc. */

Tanto la clave como las variantes de valor con y sin expresiones regulares pueden ser negadas. Entonces se seleccionan exactamente los elementos que tienen una etiqueta con la clave especificada, pero sin valor coincidente, y los elementos que no tienen una etiqueta con la clave dada:

  node["name"!="Foo"];
  node["name"!~"Foo"];
  node["name"!~"Foo",i];

La clave/valor coincide con la expresión regular (~"key regex"~"value regex")

La cuarta variante selecciona todos los elementos en los que tanto la clave como el valor coinciden con una expresión regular. Después de una virgulilla inicial (~), es necesario proporcionar la expresión regular para la clave, seguida de otro carácter de virgulilla y, eventualmente, la expresión regular para el valor.

  node[~"^addr:.*$"~"^Foo$"];    /* encuentra etiquetas addr:* con valor exactamente igual a «Foo» */
  node[~"^addr:.*$"~"^Foo"];     /* encuentra etiquetas addr:* con valor que empiece por «Foo» */
  node[~"^addr:.*$"~"Foo$"];     /* encuentra etiquetas addr:* con valor que termine en «Foo» */
  node[~"^addr:.*$"~"Foo"];      /* encuentra etiquetas addr:* con valor que contenga la subcadena «Foo» */
  node[~"^addr:.*$"~"."];        /* encuentra etiquetas addr:* con cualquier valor */
  node[~"^name(:.*)?$"~"."];     /* encuentra cualquier cosa con nombre o con etiquetas name:idioma, y con cualquier valor */
  node[~"^name(:ar|:he)?$"~"."]; /* encuentra cualquier cosa con nombre, etiquetas name:ar o name:he, y con cualquier valor*/

Este formato también permite realizar búsquedas sin tener en cuenta las mayúsculas y minúsculas: node[~"^addr:.*$"~"^Foo$",i];. La no distinción entre mayúsculas y minúsculas se aplica en este caso tanto a la búsqueda de la clave de la etiqueta como a la búsqueda de valores.

Recuadro delimitador

El filtro de consulta de recuadro delimitador selecciona todos los elementos dentro de un recuadro delimitador rectangular.

No tiene ningún conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

  (sur,oeste,norte,este)

Consiste en un paréntesis de apertura. Luego siguen cuatro números de punto flotante, separados por comas. El filtro termina con un paréntesis de cierre.

Los números de punto flotante determinan los límites del recuadro delimitador: el primero es el límite sur o la latitud mínima; el segundo es el límite occidental, normalmente la longitud mínima; el tercero es el límite norte o latitud máxima; el último es el límite oriental, normalmente la longitud máxima. Si el segundo argumento es más grande que el cuarto, el recuadro delimitador cruza la longitud de 180 grados.

Ejemplo:

  node(50.6,7.0,50.8,7.3);

Véase también: Recuadro delimitador global (bbox).

Recursividad (n, w, r, bn, bw, br)

El filtro de recursividad selecciona todos los elementos que son miembros de un elemento del conjunto de entrada o que tienen un elemento del conjunto de entrada como miembro, dependiendo del parámetro especificado.

El conjunto de entrada puede cambiarse con una notación prefija adaptada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue uno de los siguientes símbolos: w (delante de vías), r (delante de relaciones), bn (detrás de nodos), bw (detrás de vías) o br (detrás de relaciones). Luego sigue una declaración opcional de conjunto de entrada. El filtro termina con un paréntesis de cierre.

Ejemplos con el conjunto de entrada predeterminado:

  node(w);            // selecciona los nodos hijo de las vías en el conjunto de entrada
  node(r);            // selecciona los miembros de la relación de tipo nodo en el conjunto de entrada
  way(bn);            // selecciona las vías padre de los nodos en el conjunto de entrada
  way(r);             // selecciona los miembros de tipo vía de las relaciones en el conjunto de entrada
  rel(bn);            // selecciona las relaciones que tienen miembros de tipo nodo en el conjunto de entrada
  rel(bw);            // selecciona las relaciones que tienen miembros de tipo vía en el conjunto de entrada
  rel(r);             // selecciona los miembros de tipo relación de las relaciones en el conjunto de entrada
  rel(br);            // selecciona las relaciones padre de las relaciones en el conjunto de entrada

Ejemplo con el conjunto de entrada modificado:

  node(w.foo);        // selecciona los nodos hijo de las vías en el conjunto de entrada «foo»

También puedes restringir la recursividad a un rol específico. Solo hay que añadir un punto y coma y luego indicar el nombre del rol antes del paréntesis de cierre.

Ejemplos con el conjunto de entrada predeterminado:

  node(r:"role");     // selecciona los miembros de tipo nodo de las relaciones en el conjunto de entrada
  way(r:"role");      // selecciona los miembros de tipo vía de las relaciones en el conjunto de entrada
  rel(bn:"role");     // selecciona relaciones que tengan miembros de tipo nodo en el conjunto de entrada
  rel(bw:"role");     // selecciona relaciones que tengan miembros de tipo vía en el conjunto de entrada
  rel(r:"role");      // selecciona los miembros de tipo relación de las relaciones en el conjunto de entrada
  rel(br:"role");     // selecciona las relaciones padre de las relaciones en el conjunto de entrada

Ejemplo con el conjunto de entrada modificado:

  node(r.foo:"role"); // selecciona los miembros de tipo nodo con el rol «role» de las relaciones en el conjunto de entrada «foo»

Y también puedes buscar explícitamente roles vacíos:

  node(r:"");         // selecciona los miembros de tipo nodo sin rol asignado de las relaciones en el conjunto de entrada
  node(r.foo:"");     // selecciona los miembros de tipo nodo sin rol asignado de las relaciones en el conjunto «foo»

Por conjunto de entrada (.setname)

El filtro de elementos selecciona todos los elementos de su conjunto de entrada.

Como en el caso de todos los filtros, el conjunto de resultados se especifica por el enunciado completo, no por el filtro individual.

Consiste en un punto, seguido del nombre del conjunto de entrada.

Ejemplos con el conjunto predeterminado:

  node._;

y con un conjunto específico:

  node.a;

También es posible especificar varios conjuntos de entrada (intercambio de conjuntos).

Por ejemplo:

  node.a.b;
Esta declaración devuelve todos los nodos que están tanto en el conjunto de entrada a como en el conjunto de entrada .b.

Por identificador de elemento

El filtro de consulta por identificador selecciona el elemento del tipo determinado por el identificador especificado. Soporta el tipo de dato nodo de OSM, además de la vía y la relación.

No tiene un conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue un entero positivo. El filtro termina con un paréntesis de cierre.

Ejemplos:

  node(1);
  way(1);
  rel(1);
  area(1);

Nótese que los identificadores de área deben derivarse de una vía existente de OSM añadiendo 2400000000 a su identificador OSM o, en caso de una relación, añadiendo 3600000000 respectivamente. Nótese además que la creación de áreas está sujeta a algunas reglas de extracción, es decir, no todas las vías/relaciones tienen una contraparte del área. Véase areas.osm3s para conocer los detalles.

A partir de version 0.7.54, el filtro de consulta por identificador también soporta varios valores. Para evitar conflictos con el recuadro delimitador, se debe usar un nuevo prefijo obligatorio id: en este caso.

   node(id:1000,1001,1002,1003,1004,1005);
   way(id:3998029,3998240,4065354,4065364,4065392,4065421);
   rel(id:10815,10816);
   area(id:1234);

Sugerencia de rendimiento: Intenta agrupar varias consultas por identificador en una sola declaración, es decir, en lugar de escribir (way(3998029);way(3998240);way(4065354););, usa way(id:3998029,3998240,4065354);

En relación con otros elementos (around)

El filtro around selecciona todos los elementos dentro de un cierto radio alrededor de los elementos del conjunto de entrada. Si se proporcionan las coordenadas, entonces estas coordenadas se usan en lugar del conjunto de entrada. El conjunto de entrada puede ser cambiado con una notación prefija adaptada. Como para todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Se puede usar un radio de valor 0 para una comprobación de intersección de vías en puntos externos e internos.

Sintaxis: Consiste en un paréntesis de apertura. Luego sigue la palabra clave around. Luego, opcionalmente, una declaración de conjunto de entrada. Luego un único número de punto flotante que denota el radio en metros. El filtro o bien termina con un paréntesis de cierre o va seguido de dos números de punto flotante separados por comas que indican la latitud y la longitud y, finalmente, un paréntesis de cierre.

  (around[.conjunto_entrada]:rado)
  (around:radio,latitud,longitud)

a partir de version 0.7.55, es posible consultar todos los elementos que se encuentran dentro de un cierto radio de una determinada línea, que viene dada por una lista de pares latitud/longitud:

  (around[.conjunto_entrada]:radio)
  (around:radio,latitud_1,longitud_1,latitud_2,longitud_2,...,latitud_n,longitud_n)

Ejemplo:

  node(around:100.0);
  way(around:100.0);
  rel(around:100.0);

Ejemplo con conjunto de entrada modificado:

  node(around.a:100.0);

Ejemplo con coordenadas:

  node(around:100.0,50.7,7.1);
  way(around:100.0,50.7,7.1);
  rel(around:100.0,50.7,7.1);

Ejemplo con cadena lineal:

try it yourself in overpass-turbo
way[highway](around:500,50.540853270068986,8.048780365649707,50.53106288705902,8.030823236553783,50.51780737956311,8.019643105996508,50.50287491071276,8.016749912560886,50.48828159051387,8.022534398052139,50.47599950382573,8.036215335651725,50.467689755650376,8.055945038928135,50.46447690759688,8.079058902127825,50.46679590711731,8.102435269947343,50.47433280529453,8.122917034379736,50.48606755168466,8.137738019645033,50.50041288059356,8.144896569557243,50.51542994506574,8.143425882283827,50.529090915610794,8.13352458229042,50.53955268865336,8.11652989500613,50.545404823255616,8.09473704711951,50.545858734919165,8.07108928349599,50.540853270068986,8.048780365649707)   
;(._;>;);out meta;

Para más casos de uso, véase esta entrada de diario(en).

Ejemplo: Encontrar todos los nodos de cines en Bonn que están a lo sumo a 100 metros de una parada de bus.

try it yourself in overpass-turbo
area[name="Bonn"];
node(area)[highway=bus_stop];
node(around:100)[amenity=cinema];
out;

Encontrar tanto nodos de cines como vías en Bonn que están a lo sumo a 100 metros de un nodo de parada de bus:

try it yourself in overpass-turbo
area[name="Bonn"];
node(area)[highway=bus_stop]->.bus_stops;
( 
  way(around.bus_stops:100)[amenity=cinema];
  node(around.bus_stops:100)[amenity=cinema];
);
(._;>;);
out meta;

Por polígono (poly)

El filtro de polígono selecciona todos los elementos del tipo elegido dentro de un polígono determinado.

No tiene ningún conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue la palabra clave poly. Luego, una cadena que contiene un número par de números de punto flotante, separados solo por el espacio en blanco. Cada par de números de punto flotante representa una coordenada, en orden latitud y luego longitud. El filtro termina con un paréntesis de cierre:

  (poly:"latitud_1 longitud_1 latitud_2 longitud_2 latitud_3 longitud_3...");

Un ejemplo (triángulo próximo a Bonn, Alemania):

  node(poly:"50.7 7.1 50.7 7.2 50.75 7.15");
  way(poly:"50.7 7.1 50.7 7.2 50.75 7.15");
  rel(poly:"50.7 7.1 50.7 7.2 50.75 7.15");

Sugerencia de rendimiento: Un gran número de pares de latitud/longitud ralentiza el filtro (poly: ), por lo que se recomienda simplificar la geometría de la polilínea antes de utilizarla en un filtro poly.

Más reciente (newer)

El filtro newer selecciona todos los elementos que han sido cambiados desde la fecha especificada. A diferencia de otros filtros, este filtro no puede ser usado solo. Si la instancia de la base de datos subyacente admite datos attic y la diferencia de fecha es de un mes como máximo, entonces «changed» probablemente sea mejor opción que «newer».

No tiene ningún conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue una especificación de fecha. Ten en cuenta que esta especificación de la fecha no puede estar abreviada y tiene que ser puesta entre comillas simples o dobles. El filtro termina con un paréntesis de cierre.

Ejemplo:

  node._(newer:"2012-09-14T07:00:00Z");
Esto encuentra todos los nodos que han cambiado desde el 14 de septiembre de 2012, 7 h UTC, en el conjunto de entrada especificado.

Por fecha de cambio (changed)

El filtro changed selecciona todos los elementos que han sido cambiados entre dos fechas determinadas. Si solo se da una fecha, se supone que la segunda es la fecha inicial de la base de datos. Si solo se da una fecha y se ejecuta con la marca de tiempo actual, entonces se comporta exactamente como «newer» con dos excepciones: primero, es más rápido (véase nota al respecto); segundo, puede ser también el único filtro.

Nota: A partir de junio de 2017, un fallo conocido puede hacer que «changed» sea mucho más lento que «newer» en algunos casos. Considera la posibilidad de usar «newer» hasta que se solucione este fallo o prueba cuál se ejecuta más rápido para ti. Véanse las siguientes incidencias de GitHub: #278, #322 y #346. Consulta también esta discusión.

No tiene ningún conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue una especificación de fecha. Ten en cuenta que esta especificación de la fecha no puede estar abreviada y tiene que ser puesta entre comillas simples o dobles. Luego puede seguir una coma y una segunda especificación de fecha. El filtro termina con un paréntesis de cierre.

Ejemplo: Todos los cambios desde la fecha especificada hasta el instante actual

  node._(changed:"2012-09-14T07:00:00Z");

Ejemplo: Todos los cambios entre dos fechas especificadas

  node._(changed:"2012-09-14T07:00:00Z","2012-09-14T07:01:00Z");

Por usuario (user, uid)

El filtro user selecciona todos los elementos que han sido tocados por última vez por el usuario especificado.

No tiene conjunto de entrada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue la palabra clave user, dos puntos y una cadena literal que indica el nombre del usuario a buscar. O la palabra clave uid seguida del nombre de usuario del usuario a buscar. El filtro termina con un paréntesis de cierre.

Ejemplo:

  node(user:"Steve");
  node(uid:1);

A partir de la versión 0.7.53, también es posible especificar varios nombres de usuarios:

  node(user:"Mapeador_1","Mapeador_2","Mapeador_3");
  node(uid:1,2,4,8,16);

Por área (area)

El filtro area selecciona todos los elementos del tipo elegido que estén dentro del área especificada. Ten en cuenta que, con respecto a los datos attic, las áreas siempre representan datos actuales.

El conjunto de entrada puede ser cambiado con una notación prefija adaptada. Como en todos los filtros, el conjunto de resultados se especifica por la notación completa, no por el filtro individual.

Sintaxis: Consiste en un paréntesis de apertura. Luego sigue la palabra clave area. Luego puede seguir un signo de dos puntos y un entero no negativo. El filtro termina con un paréntesis de cierre.

Los nodos se encuentran si están dentro o en el borde del área. Las vías se encuentran si al menos un punto (también puntos en el segmento) está dentro del área. Una vía no se encuentra si termina en el borde y no cruza el área. Las relaciones se encuentran si uno de sus miembros está dentro del área.

Si la declaración area se introduce sin el número entero, se usan las áreas del conjunto de entrada. Un ejemplo:

  node(area);
  way(area);
  rel(area);

El ejemplo con el conjunto de entrada modificado:

  node(area.a);
  way(area.a);
  rel(area.a);

Si se añade un número entero, se ignora el conjunto de entrada y, en su lugar, se toma el área que tiene el número entero especificado como identificador. Por ejemplo:

  node(area:2400000001);
  way(area:2400000001);
  rel(area:2400000001);

Advertencia: area(area); no está actualmente soportado. En este caso, el filtro (area) será ignorado discretamente, lo que dará lugar a resultados inesperados.

Debido a que las áreas en OSM no son elementos nativos sino que solo se infieren de la base de datos de OSM usando sus vías o relaciones cerradas, esta funcionalidad permite agrupar sus diversas representaciones en un conjunto coherente que puede almacenar su geometría, independientemente de su complejidad y representación en la base de datos de OSM, como si fuera un único elemento distintivo, sin emplear complejas reglas de filtrado en su consulta. Sin embargo, la asociación de estos objetos con un atributo identificador de OSM requiere ciertos ajustes, ya que el mismo valor de identificador podría estar siendo usado para elementos no relacionados con tipología diferente (vía o relación). Por esta razón, las áreas devueltas por la API de Overpass solo tienen un identificador «virtual» específico de la API de Overpass, pero no se encuentran directamente en la base de datos de OSM.

Por convención, el identificador del área se puede calcular a partir de una vía de OSM existente añadiendo 2400000000 a su identificador OSM, o en el caso de una relación, añadiendo 3600000000 respectivamente. Nótese que la creación de áreas está sujeta a algunas reglas de extracción, es decir, no todas las vías/relaciones tienen una contraparte del área (sobre todo aquellas que están etiquetadas con area=no, y la mayoría de los multipolígonos y que no tienen un name=* definido no formarán parte de las áreas).

Las áreas son creadas por un trabajo regular en el servidor API de Overpass y normalmente tienen un retraso de varias horas en comparación con la base de datos principal de OSM. La marca de tiempo exacta se puede determinar comprobando el valor de «timestamp_areas_base» en los resultados json o xml de Overpass.

Si deseas obtener resultados más inmediatos (sin depender del procesamiento por lotes retardado), también puedes escribir tus propios filtros sin usar esta funcionalidad en tu consulta de Overpass: usa tipos e identificadores de elementos estándares de OSM y fíltralos por etiquetas específicas de tu elección.

Véase areas.osm3s para obtener detalles de los filtros (escritos usando la variante XML del lenguaje de consulta Overpass) que actualmente emplea Overpass para generar las áreas que pueden ser consultadas con esta funcionalidad. Esas áreas se definen mediante la función de consulta pivot (véase más adelante).

Pivote de área (pivot)

El filtro pivot selecciona el elemento de los tipos escogidos que definen el contorno del área especificada.

El conjunto de entrada puede cambiarse con una notación prefija adaptada. Como en todos los filtros, el conjunto de resultados se especifica por la declaración completa, no por el filtro individual.

Consiste en un paréntesis de apertura. Luego sigue la palabra clave pivot. El filtro termina con un paréntesis de cierre.

La declaración encuentra para cada área del conjunto de entrada el elemento o elementos respectivos a partir de los cuales se ha generado el área. Esta será una relación multipolígono o una vía.

Ejemplos:

// Estas usan el conjunto predeterminado '_'
way(pivot);
rel(pivot);
// Estas usan el conjunto de entrada 'a'
way(pivot.a);
rel(pivot.a);

El siguiente ejemplo determina la(s) área(s) del condado de Gran Londres y almacena el resultado en el conjunto arealondres. En la siguiente declaración, las áreas contenidas en el conjunto arealondres se convierten de nuevo en sus correspondientes relaciones OSM usando el filtro pivot. Finalmente, out geom; da salida a las relaciones (incluyendo sus vías y nodos hijos).

area[name="London"][admin_level=6][boundary=administrative]->.arealondres;
rel(pivot.arealondres);
out geom;

Filtro de consulta condicional (if:)

a partir de v0.7.54

El filtro de consulta puede añadirse como condición a una declaración de consulta. Tiene un evaluador como argumento y deja pasar solo aquellos elementos para los cuales la expresión devuelve verdadero booleano.

Por el momento, el filtro de consulta no puede ser la única condición en una consulta. Esto se debe a razones de implementación y cambiará en futuras versiones.

Es técnicamente posible tener múltiples filtros de consulta en una sola consulta, pero no tiene sentido porque:

  • Sus evaluadores pueden combinarse con una conjunción en un único filtro de consulta.
  • Esto tiene la misma semántica y es más rápido.

Su sintaxis es:

 (if: <Evaluador>)

El espacio en blanco es opcional.

Muchos de los filtros anteriores pueden generalizarse usando el filtro de consulta condicional, si se necesitan condiciones más específicas para filtrar los objetos del conjunto de entrada de la consulta. Por ejemplo, la consulta:

  node[name=foo];

es equivalente a lo siguiente, que emplea un filtro de consulta condicional (pero para simplificar, se sigue recomendando la antigua sintaxis que emplea un filtro más simple por valor de etiqueta, ya que puede tener un mejor rendimiento en el servidor Overpass, y porque la nueva sintaxis para los evaluadores puede todavía no estar soportada en la actual implementación de los servidores Overpass y las bibliotecas de clientes antes de la versión 0.7.54 de la API):

  node(if: t["name"] == "foo");

Evaluadores

Los evaluadores son bloques básicos que producen un valor en la ejecución. El sentido de usar uno u otro evaluador dependerá del contexto.

Los evaluadores ayudan a filtrar los elementos dentro de una declaración de consulta. Permiten obtener información estadística sobre los resultados de la consulta y quitar o añadir etiquetas de los elementos.

Actualmente solo se admiten las etiquetas de los evaluadores. Los evaluadores de geometría están planeados pero no implementados en esta versión.

Los siguientes tipos de evaluadores existen y se explican más adelante:

  • Los evaluadores constantes ofrecen siempre el mismo valor, independientemente del contexto.
  • Los evaluadores dependientes de los elementos entregan información sobre un objeto individual.

Solo tienen sentido en el contexto de un solo elemento.

  • Los evaluadores estadísticos entregan información sobre un conjunto como un todo.
  • Los agregadores dejan que un evaluador dependiente de un elemento haga un bucle sobre todos los elementos de un conjunto y combine sus resultados.
  • Los operadores y endomorfismos combinan el resultado de una o dos ejecuciones del evaluador en un nuevo resultado.

Por hacer:

  • Es necesario añadir ejemplos sencillos para cada sección, de forma similar a, por ejemplo, las expresiones regulares anteriores.
  • Fusionar algunas de las explicaciones simples de las entradas del blog en este documento.

Literales

Los literales representan valores fijos, y pueden ser usados para comparaciones y comprobaciones contra los operadores, o como argumentos para los evaluadores. Ejemplos de literales:

Literal Explicación
3 El valor del número entero 3 †*
3.14159 El número de punto flotante 3.14159 †*
2017-09-28T19:51:44Z Una marca de tiempo en formato ISO 8601, el formato de uso común en la base de datos de OpenStreetMap.

El formato es YYYY-MM-DDThh:mm:ssZ. ‡

London Bridge Una cadena de caracteres ‡
addr:housenumber Una cadena que representa una clave de OpenStreetMap de uso común, addr:housenumber

† Los números enteros y números en coma flotante tratados como números y expresados como menores que cero (p. ej., -1.3) no son por sí mismos literales. Son literales modificados con el operador de menos unitario.

* Algunos enteros positivos y negativos y números de punto flotante, (tales como los que se usan en el contexto del filtro de consulta de recuadro delimitador) son interpretados como cadenas.

‡ Generalmente es prudente incluir comillas enmarcando estos literales, para evitar la posibilidad de que caracteres como : - o espacio en blanco sean interpretados incorrectamente por un evaluador. Por ejemplo, "London Bridge" y "addr:housenumber" evitan problemas de análisis dentro de los evaluadores de etiquetas. "2017-09-28T19:51:44Z" es una forma segura de escribir un literal de marca de tiempo.

Algunas funciones, tales como date(), intentará escribir un literal en un formato estándar adecuado para Overpass QL.a

Evaluador de valores fijos

Este operador siempre devuelve un valor fijo. No hace falta ningún argumento.

Su sintaxis es

 <Valor>

Operador dependiente del elemento

Los operadores dependientes del elemento dependen a su vez de un parámetro o, en su defecto, de ninguno. Su sintaxis varía, pero la mayoría tiene la apariencia de un nombre de función acompañado de unos paréntesis.

Solo se pueden llamar en un contexto en el que se procesan elementos. Esto se aplica a la conversión, al filtro o a los argumentos de las funciones de agregación. No pueden ser llamados directamente desde make.

Identificador y tipo de elemento

El operador id devuelve el identificador del elemento. El operador type devuelve el tipo de elemento. Ambos operadores no toman ningún parámetro.

La sintaxis es

 id()

o bien

 type()

Operadores de valores de etiqueta y valores genéricos

El operador de etiqueta devuelve el valor de la etiqueta de la llave especificada. El operador is_tag devuelve «1» si el elemento especificado tiene una etiqueta con esa clave y «0» en caso contrario. Solo se pueden llamar en el contexto de un elemento.

Sus sintaxis son

 t[<Nombre de clave>]

o bien

 is_tag(<Nombre de clave >)

El <Nombre de clave> debe estar entre comillas si contiene algún carácter especial.

El operador de etiqueta también puede ser llamado con una subdeclaración. Su sintaxis es entonces

 t[<Subdeclaración>]

El operador de etiqueta genérica devuelve el valor de la etiqueta de la clave que se pide. Solo puede ser llamado en el contexto de un elemento. Además, debe formar parte del valor de una propiedad genérica para que se especifique su clave.

Su sintaxis es

 ::

Evaluador de todas las claves

El evaluador de todas las claves devuelve un contenedor de las claves del elemento especificado.

Su sintaxis es

 keys()

Operadores de metadatos

El operador version devuelve el número de versión de un elemento dado.

Su sintaxis es

 version()

El operador timestamp devuelve la marca de tiempo de un elemento dado.

Su sintaxis es

 timestamp()

El operador changeset devuelve el identificador de conjunto de cambios del conjunto de cambios en el que el elemento dado ha sido editado por última vez.

Su sintaxis es

 changeset()

El operador uid devuelve el identificador del usuario que ha tocado por última vez el elemento dado.

Su sintaxis es

 uid()

El operador user devuelve el nombre del usuario que ha tocado por última vez el elemento dado.

Su sintaxis es

 user()

Recuento de las propiedades de los elementos

a partir de v0.7.55

Esta variante del operador count cuenta etiquetas o miembros del elemento dado. A diferencia de la variante estadística del operador de conteo, no pueden tomar un conjunto de entradas como argumento adicional.

La sintaxis para etiquetas es

 count_tags()

La sintaxis para contar el número entradas de miembros es

 count_members()

La sintaxis para contar el número de miembros distintos es

 count_distinct_members()

La sintaxis para contar el número de entradas de miembros con un rol específico es

 count_by_role()

La sintaxis para contar el número de miembros distintos con un rol específico es

 count_distinct_by_role()

Agregadores por miembro

Los agregadores por miembro ayudan a procesar la información que se aplica a un solo miembro de una vía o una relación. Ejemplos de ello son la posición dentro de la vía o relación y las propiedades geométricas como los ángulos o los roles. Un agregador por miembro necesita un elemento para operar y ejecuta su argumento varias veces, pasando las posibles posiciones una por una además del elemento a su argumento.

Por miembro

a partir de v0.7.56

Para cada elemento, el agregador ejecuta su argumento una vez por cada miembro del elemento. El valor de retorno es una lista de valores de resultados separados por punto y coma. No se produce ninguna deduplicación ni ordenación. Ten en cuenta que el agregador devuelve un valor vacío para los nodos y derivados, y no ejecuta su argumento en ese caso.

La sintaxis es

 per_member(<Evaluador>)

Por vértice

a partir de v0.7.56

Para cada elemento, el agregador ejecuta su argumento una vez por vértice (interior) del elemento. De lo contrario, se comporta de manera similar al operador por_miembro. En el caso de vías cerradas, esto significa que se ejecuta una vez para todos los vértices, excepto el primer miembro. Para vías abiertas, se ejecuta una vez para todos los vértices excepto el primer y último miembro. Para las relaciones, su comportamiento es actualmente indefinido.

La sintaxis es

 per_vertex(<Evaluador>)

Funciones dependientes de los miembros

Las funciones de dependencia de los miembros solo pueden usar cuando un elemento más una posición dentro del elemento están en contexto. Entonces devuelven información específica para ese miembro.

Posición del miembro

a partir de v0.7.56

La función de posición devuelve para un miembro su posición de base única dentro del elemento.

La sintaxis es

 pos()

Referencia al miembro

a partir de v0.7.56

La función de referencia y mtype devuelven el identificador y el tipo, respectivamente, para un miembro del objeto referenciado.

La sintaxis es

 mtype()

o bien

 ref()

Rol del miembro

a partir de v0.7.56

La función role devuelve el rol del miembro.

Su sintaxis es

 role()

Ángulo de una vía en la posición de un miembro

a partir de v0.7.56

Esta función devuelve el ángulo entre el segmento que termina en este miembro y el segmento que empieza allí. Hasta ahora solo está definida para las vías. Si la vía es una vía cerrada, entonces para el último miembro el primer segmento se usa como segmento de inicio. Esta función está pensada para ser usada dentro del enumerador per_vertex().

La sintaxis es

 angle()

Operadores relacionados con la geometría

Cercanía

a partir de v0.7.55

El operador is_closed indica si el elemento es una vía cerrada. El operador no está definido para ningún otro tipo de elemento. Para las vías, devuelve «1» si el primer miembro de la vía es igual al último miembro de la vía, y «0» en caso contrario. Los operadores no toman ningún parámetro.

La sintaxis es

 is_closed()

Geometría

a partir de v0.7.55

El operador de geometría devuelve la geometría de un solo objeto como una geometría que puede ser puesta en otros operadores de conversión de geometría.

Su sintaxis es

 geom()

Longitud (length)

a partir de v0.7.55

El operador de longitud devuelve la longitud del elemento. Para las vías, es la longitud de la vía. Para las relaciones, la suma de las longitudes de los miembros de tipo vía. Para los nodos, siempre es cero.

Su sintaxis es

 length()

Latitud y longitud

a partir de v0.7.56

Los operadores de latitud y longitud devuelven la respectiva coordenada geográfica del elemento o del centro del elemento. Para los nodos es la latitud o la longitud de la coordenada del nodo. Para las vías y relaciones se refiere a la coordenada derivada del centro del recuadro delimitador.

Sus sintaxis son

 lat()

o bien

 lon()

Evaluador de punto

a partir de v0.7.55

El evaluador de punto, con sintaxis pt(<latitud>, <longitud>), devuelve una geometría de nodo OpenStreetMap válida. La geometría devuelta es un nodo en la latitud y longitud derivadas a partir de los dos valores especificados. Cada valor proporcionado por el usuario, latitud y longitud, debe ser analizado como un número válido de punto flotante.

  • La latitud debe estar dentro del rango -90 a 90, ambos inclusive. Los dígitos más allá 10e-7 (que está más allá de la precisión en la que OpenStreetMap guarda un nodo) son ignorados si están dentro de este rango.
  • La longitud debe estar dentro del rango -180 a 180, ambos inclusive. Los dígitos más allá 10e-7 (que está más allá de la precisión en la que OpenStreetMap guarda un nodo) son ignorados si están dentro de este rango.

Evaluador de cadena lineal

a partir de v0.7.55

Este operador siempre devuelve una geometría. La geometría es una línea formada por los puntos que se proporcionan como argumentos.

Su sintaxis es

 lstr(<Evaluador>, <Evaluador>[, ...])

Evaluador de polígonos

a partir de v0.7.55

Este operador siempre devuelve una geometría. La geometría es un polígono formado por las líneas que se proporcionan como argumentos. El polígono sigue la regla de la mano derecha y no tiene autointerferencias.

Su sintaxis es

 poly(<Evaluador>, <Evaluador>[, ...])

Agregadores

Los agregadores necesitan para su ejecución tanto un conjunto para operar como un evaluador como argumento. Ese evaluador hará un bucle sobre cada elemento del conjunto, y el agregador combinará sus resultados.

Unión y conjunto

Estas dos funciones de agregación ejecutan sus evaluadores sobre cada elemento de un conjunto especificado, devolviendo un valor de texto.

La sintaxis básica es

 <Conjunto>.u(<Evaluador>)
 <Conjunto>.set(<Evaluador>)

Para el conjunto predeterminado _, el parámetro del conjunto puede dejarse sin especificar:

 u(<Evaluador>)
 set(<Evaluador>)

set devuelve una lista de todos los distintos valores que aparecen separados por signos de punto y coma.

u está destinado a operar en conjuntos que devuelven un valor único, como los conjuntos con un solo miembro. Si solo se encuentra un valor, entonces ese valor es devuelto. Si no se encuentra ningún valor, entonces la u devuelve una cadena vacía. Si se encuentran varios valores diferentes, entonces u devuelve el texto «< multiple values found >» (múltiples valores encontrados).

Mínimo y máximo

La declaración básica es

 <Conjunto>.min(<Evaluador>)

o bien

 <Conjunto>.max(<Evaluador>)

Si el conjunto es el predeterminado _, entonces puedes prescindir del parámetro de conjunto:

 min(<Evaluador>)

o bien

 max(<Evaluador>)

Estos dos evaluadores ejecutan sus evaluadores del lado derecho en cada elemento del conjunto especificado. Si todos los valores de salida son números válidos, entonces min devuelve el mínimo entre los números. De la misma manera, si todos los valores de salida son números válidos, entonces max devuelve el máximo entre los números. Si no todos los valores de salida son números válidos, entonces min devuelve la primera cadena lexicográfica. De la misma manera, si no todos los valores de salida son números válidos, entonces max devuelve la última cadena lexicográfica. Si no se encuentra ningún valor, entonces cada min y max devuelven una cadena vacía.

Suma

La sintaxis básica es

 <Conjunto>.sum(<Evaluador>)

Si el conjunto es el conjunto predeterminado _, entonces puedes prescindir del parámetro de conjunto:

 sum(<Evaluador>)

Este evaluador ejecuta sus evaluadores del lado derecho en cada elemento del conjunto especificado. Si todos los valores de salida son números válidos, entonces sum devuelve su suma. Si no todos los valores de salida son números válidos, entonces sum devuelve «NaN»

Recuento estadístico

Esta variante del operador count cuenta elementos de un tipo determinado en un conjunto.

Las variantes de sintaxis

 count(nodes)
 count(ways)
 count(relations)
 count(deriveds)
 count(nwr)
 count(nw)
 count(wr)
 count(nr)

cuentan los elementos en el conjunto predeterminado _, mientras que las variantes de sintaxis

 <Conjunto>.count(nodes)
 <Conjunto>.count(ways)
 <Conjunto>.count(relations)
 <Conjunto>.count(deriveds)
 <Conjunto>.count(nwr)
 <Conjunto>.count(nw)
 <Conjunto>.count(wr)
 <Conjunto>.count(nr)

cuentan los elementos en el conjunto <Conjunto>.

Unión de geometrías

a partir de v0.7.55

La sintaxis básica es

 <Conjunto>.gcat(<Evaluador>)

Si el conjunto es el conjunto predeterminado _, entonces puedes prescindir del parámetro de conjunto:

 gcat(<Evaluador>)

El evaluador ejecuta su evaluador del lado derecho en cada elemento del conjunto especificado. Luego combina las geometrías obtenidas en un gran objeto. Si las geometrías están contenidas varias veces en el grupo, entonces también se repiten como miembros del resultado.

Operadores unarios

Los operadores unarios necesitan para su ejecución un operando. Siempre se escriben en notación prefija. Los operadores se pueden agrupar con paréntesis.

Las dos variantes

 <Operador><Evaluador>

y

 (<Operador><Evaluador>)

tienen como expresiones autónomas precisamente la misma semántica. La variante del paréntesis existe para anular la precedencia del operador.

El orden de precedencia es el siguiente, ordenado de débil a fuerte:

  • disyunción lógica
  • conjunción lógica
  • igualdad, desigualdad
  • menor, menor-igual, mayor-igual, mayor-igual
  • más, menos binario
  • multiplicación, división
  • negación lógica
  • menos unario

A continuación, los operadores se ordenan por orden de precedencia, con una mayor vinculación en último lugar.

Negación booleana

La negación booleana se evalúa como «1» si su argumento se evalúa como una representación del falso booleano. En caso contrario, se evalúa como «0». Las representaciones del falso booleano son la std::string vacía y cualquier std::string que sea una representación numérica de cero. Cualquier otra std::string representa el verdadero booleano.

Su sintaxis es

 ! <Evaluador>

El espacio en blanco es opcional.

Menos unario

El operador del menos unario niega su argumento. Si el argumento es un número entero o un número con coma flotante, entonces se niega como un número entero o como un número con coma flotante. En caso contrario, el operador de menos unario devuelve «NaN».

La sintaxis del menos unario es:

 - <Evaluador>

El espacio en blanco es opcional.

Operadores binarios

Los operadores binarios necesitan para su ejecución dos operandos. Siempre se escriben en notación infijo. Los operadores se pueden agrupar con paréntesis.

Las dos variantes

 <Evaluador><Operador><Evaluador>

y

 (<Evaluador><Operador><Evaluador>)

tienen como expresiones autónomas precisamente la misma semántica. La variante del paréntesis existe para anular la precedencia del operador:

 2 + 3 * 4

se evalúa como 2 + 12 y luego, finalmente, 14.

 (2 + 3) * 4

se evalúa como 5 * 4, y luego, finalmente, 20.


El orden de precedencia es el siguiente, ordenado de débil a fuerte:

  • el operador ternario
  • disyunción lógica
  • conjunción lógica
  • igualdad, desigualdad
  • menor, menor-igual, mayor, mayor-igual
  • más, menos binario
  • multiplicación, división
  • negación lógica
  • menos unario

A continuación, los operadores se ordenan por orden de precedencia, con una mayor vinculación en último lugar.

Disyunción booleana

La disyunción booleana se evalúa como «1» si uno o ambos de sus argumentos se evalúan como una representación del verdadero booleano. En caso contrario, se evalúa como «0». Las representaciones del falso booleano son la cadena vacía y cualquier cadena que sea una representación numérica de cero. Cualquier otra cadena representa el verdadero booleano. Actualmente, ambos argumentos siempre se evalúan. Esto puede cambiar en futuras versiones.

Su sintaxis es

 <Evaluador> || <Evaluador>

El espacio en blanco es opcional.

Conjunción booleana

La conjunción booleana se evalúa como «1» si ambos argumentos se evalúan como una representación del verdadero booleano. En caso contrario, se evalúa como «0». Las representaciones del falso booleano son la cadena vacía y cualquier cadena que sea una representación numérica de cero. Cada otra cadena representa el verdadero booleano. Actualmente, ambos argumentos se evalúan siempre. Esto puede cambiar en futuras versiones.

Su sintaxis es

 <Evaluador> && <Evaluador>

El espacio en blanco es opcional.

Igualdad y desigualdad

El operador de igualdad se evalúa como «1» si ambos argumentos son iguales. En caso contrario, se evalúa como «0». El operador de desigualdad se evalúa como «0» si ambos argumentos son iguales. En caso contrario, se evalúa como «1». Si ambos argumentos pueden interpretarse como enteros, entonces se comparan los valores representados. En otro caso, si ambos argumentos pueden interpretarse como números con coma flotante, entonces se comparan los valores representados. En todos los demás casos, los argumentos se tratan como cadenas.

Su sintaxis para igualdad es

 <Evaluador> == <Evaluador>

y para desigualdad

 <Evaluador> != <Evaluador>

El espacio en blanco es opcional.

Menor, menor-igual, mayor y mayor-igual

Estos operadores se evalúan como «1» si sus argumentos se comparan respectivamente. En caso contrario, se evalúan como «0». Si ambos argumentos pueden interpretarse como enteros, entonces se comparan los valores representados. En otro caso, si ambos argumentos pueden interpretarse como números con coma flotante, entonces se comparan los valores representados. En todos los demás casos, los argumentos se tratan como cadenas.

Las sintaxis para menor, menor-igual, mayor y mayor-igual en este orden son

 <Evaluador> < <Evaluador>
 <Evaluador> <= <Evaluador>
 <Evaluador> > <Evaluador>
 <Evaluador> >= <Evaluador>

El espacio en blanco es opcional.

Más y menos

Aunque ambos operadores tienen la misma prioridad, aceptan diferentes tipos de argumentos. Si los argumentos son ambos enteros, entonces se suman o se restan como números enteros. Si los argumentos son ambos números con coma flotante, entonces se suman o se restan como números con coma flotante. En caso contrario, el operador más (+) concatena los argumentos como cadenas. Por contra, el operador menos (-) devuelve «NaN».

El menos unario es un operador distinto del operador binario menos definido aquí. Tiene una mayor prioridad.

Las sintaxis para el más (+) y el menos (-) en este orden son

 <Evaluador> + <Evaluador>
 <Evaluador> - <Evaluador>

El espacio en blanco es opcional.

Multiplicación y división

El operador de multiplicación y el operador de división realizan las respectivas operaciones aritméticas. Si los argumentos son ambos enteros, entonces se multiplican como enteros. Si los argumentos son ambos números en coma flotante, se multiplican o dividen como números en coma flotante. La división trata los números enteros como números con coma flotante. Si uno o ambos argumentos no son números, entonces ambos operadores devuelven «NaN».

Las sintaxis para más y menos en este orden son

 <Evaluador> * <Evaluador>
 <Evaluador> / <Evaluador>

El espacio en blanco es opcional.

Operador ternario

El operador ternario necesita para su ejecución tres operandos. Si el primer operando se evalúa como verdadero booleano, entonces se evalúa lo que el segundo operando evalúa. De lo contrario, se evalúa lo que el tercer operando evalúa.

Las dos variantes

 <Evaluador>?<Evaluador>:<Evaluador>

y

 (<Evaluador>?<Evaluador>:<Evaluador>)

tienen como expresiones autónomas precisamente la misma semántica. La variante del paréntesis existe para anular la precedencia del operador. Para la precedencia, véanse los operadores binarios.

Endomorfismos de cadena

Los endomorfismos de cadena son funciones con un argumento. Muchas de ellas ayudan a normalizar o comprobar el valor de su argumento. Siempre dejan primero que su argumento sea evaluado.

Sus sintaxis son siempre

 <Nombre de función>(<Evaluador>)

Comprobación de números, normalizador y sufijo

La función number convierte su argumento en un número. Si su argumento comienza con un número, entonces el número devuelve ese número en un formato normalizado. En caso contrario, devuelve «NaN». La función is_number comprueba si su argumento comienza con un número. Devuelve «1» si su argumento puede ser analizado como un número y «0» en caso contrario. La función suffix devuelve el sufijo, si lo hay, después del número en su argumento. Si el argumento no comienza con un número, entonces devuelve la cadena vacía.

Sus sintaxis son

 number(<Evaluador>)

o bien

 is_number(<Evaluador>)

o bien

 suffix(<Evaluador>)

Comprobación de fechas y normalizador

La función date convierte su argumento en un número que representa una fecha. Si su argumento es una fecha, entonces date devuelve el número que representa el valor de su argumento. El valor resultante solo puede usar para operaciones de comparación, no puede usarse para ningún tipo de cálculos (por ejemplo, diferencias de tiempo).

La función is_date comprueba si su argumento representa una fecha. Devuelve «1» si su argumento puede ser analizado como una fecha y «0» en caso contrario.

Una cadena se analiza como fecha de la siguiente manera:

  • el primer grupo de dígitos se entiende como el año
  • el siguiente grupo de dígitos, si está presente, se entiende como el mes
  • luego, el siguiente grupo, si está presente, se entiende como el día
  • si hay más grupos de dígitos presentes, entonces se entienden como hora, minuto y segundo

Para ser una fecha, el año debe ser mayor de 1000; el mes, si está presente, menos o igual a 12; el día, si está presente, menor o igual a 31; la hora, si está presente, menor o igual a 24; y el minuto y el segundo, si están presentes, menores o iguales a 60.

El analizador de fechas podría ser más liberal en futuras versiones y aceptar más representaciones de fechas.

La sintaxis de la función es

 date(<Evaluador>)

o bien

 is_date(<Evaluador>)

Endomorfismos de geometría

Los endomorfismos de geometría son funciones con un argumento. Muchos de ellos ayudan a normalizar o comprobar el valor de su argumento. Siempre dejan que su argumento sea evaluado primero.

Su sintaxis es siempre

 <Nombre de función>(<Evaluador>)

Centro

a partir de v0.7.55

La función centro devuelve el centro de su argumento. Espera una función que evalúe a una geometría. Luego entrega el punto que está en el centro del recuadro delimitador de la geometría.

Su sintaxis es

 center(<Evaluador>)

Traza

a partir de v0.7.55

La función trace devuelve la traza de su argumento. Espera una función que evalúe a una geometría. Luego devuelve una colección de todos los segmentos y nodos que aparecen en su entrada. Las formas se dividen en puntos que están explícitamente en el conjunto y en puntos que pertenecen a más de una dirección en el conjunto. Cada nodo y segmento está contenido a lo sumo una vez.

Su sintaxis es

 trace(<Evaluador>)

Envolvente (hull)

a partir de v0.7.55

La función hull devuelve la envolvente convexa de su argumento. Espera una función que evalúe a una geometría. Luego devuelve un polígono sin huecos que contiene todos sus argumentos.

Su sintaxis es

 hull(<Evaluador>)

Lista de operadores de conjuntos representados

A veces es necesario representar varios valores en el valor de una etiqueta. Aunque de ninguna manera es obligatorio por el formato de los datos, la solución de hecho es representar un conjunto de valores mediante una lista separada por punto y coma de esos valores.

En esta sección se ofrecen algunas funciones para facilitar el manejo de estas listas. Actualmente, el delimitador está codificado con punto y coma. En aras de la simplicidad, se ignora el espacio en blanco que va delante o detrás de cada entrada de la lista.

Nótese también que las listas se entienden como conjuntos. Esto significa que el orden de los elementos de la lista no importa.

Lista de operadores teóricos de conjuntos representados

lrs_in

a partir de v0.7.55

La función lrs_in devuelve «1» si su primer argumento está contenido en el segundo argumento tratado como conjunto. En caso contrario, devuelve «0».

La sintaxis de la función es

 lrs_in(<Evaluador>, <Evaluador>)
lrs_isect

a partir de v0.7.55

La función lrs_isect devuelve la intersección de sus dos argumentos tratados como conjuntos. Si los argumentos no tienen valores en común, entonces se devuelve la cadena vacía.

La sintaxis de la función es

 lrs_isect(<Evaluador>, <Evaluador>)
lrs_union

a partir de v0.7.55

La función lrs_union devuelve la unión de sus dos argumentos tratados como conjuntos.

La sintaxis de la función es

 lrs_union(<Evaluador>, <Evaluador>)

Lista de operadores estadísticos de conjuntos representados

lrs_min

a partir de v0.7.55

La función lrs_min devuelve el mínimo de los elementos de su argumento tratados como conjunto. Si todas las entradas son números, entonces la comparación es numérica.

La sintaxis de la función es

 lrs_min(<Evaluador>)
lrs_max

a partir de v0.7.55

La función lrs_max devuelve el máximo de los elementos de su argumento tratados como conjunto. Si todas las entradas son números, entonces la comparación es numérica.

La sintaxis de la función es

 lrs_max(<Evaluador>)

Evaluador de conjuntos clave-valor

Los conjuntos pueden tener no solo miembros. También pueden tener propiedades asignadas por otras declaraciones.

La sintaxis es

 <Conjunto>.<Propiedad>

A diferencia de la mayoría de otras situaciones, es obligatorio declarar explícitamente el conjunto.

Sintaxis especial

Comentarios

Overpass QL permite comentarios en el mismo estilo de código fuente C, C++, Javascript o CSS:

  out; // Un comentario de una sola línea
  /* Los comentarios que empiezan con una barra-asterisco deben cerrarse siempre con una barra-asterisco. */
  /* Pero pueden abarcar
         múltiples líneas. */

Consultas de Overpass Turbo extendidas

Las consultas de Overpass Turbo extendidas no son parte de las especificaciones del lenguaje Overpass QL. No obstante, Overpass QL es un componente básico del código generado por el asistente de consultas de Overpass Turbo, y conocer los atajos que proporcionan las consultas de Overpass Turbo extendidas es útil cuando se consulta un servidor Overpass Turbo. Es probable que en algún momento te encuentres con esta sintaxis al ver ejemplos de consultas de Overpass Turbo.

Las consultas de Overpass Turbo extendidas pueden identificarse mediante llaves dobles, {{ }}. Para una lista completa de estas consultas y sus propósitos, véase Consultas de Overpass Turbo extendidas.

Una de ellas, por dar un ejemplo, {{data:overpass,server=http://dev.overpass-api.de/api_mmd/}}, se usa para dirigir una consulta a la instancia de desarrollo de la API de Overpass y su actual rama de código.

Escape

Se reconocen las siguientes secuencias de escape de estilo C (también definidas en Javascript) para la representación de caracteres:

  • \n escapa a una nueva línea
  • \t escapa a una tabulación
  • \" o \' escapa a las respectivas comillas
  • \\ escapa a la barra invertida
  • \u#### (los caracteres almohadilla significan cuatro dígitos hexadecimales) escapa a la respectiva unidad de código Unicode UTF-16, véanse las secuencias de escape Unicode.
    Ten en cuenta que la base de datos codifica los caracteres en UTF-8 en 1 byte (solo los caracteres del subconjunto de caracteres US-ASCII de 7 bits en el rango U+0000..U+007F) o más. Todos los caracteres a los que se les asigna un valor escalar de Unicode en los 17 planos estándares se codifican como UTF-8.
    No obstante, esta sintaxis solo admite caracteres asignados en el Plano Básico Multilingüe (Basic Multilingual Plane o BMP, por sus siglas en inglés), excluyendo los sustitutos que no son caracteres Unicode y que no tienen una codificación UTF-8 válida (incluso si los puntos de código asignados a los sustitutos tienen un valor escalar de 16 bits). Los caracteres no ASCII en el BMP se codifican con UTF-8 en 2 bytes (en el rango U+0080..U+07FF) o 3 bytes (en el rango U+0800..U+FFFF, menos los sustitutos en el rango U+D800..U+DFFF).
    Los caracteres Unicode fuera del BMP pueden ser representados en UTF-16 como un par de sustitutos: solo los pares válidos de sustitutos de UTF-16 (un sustituto alto en U+D800..U+DBFF inmediatamente seguido de un sustituto bajo en U+DC00..U+DFFF) son convertibles a UTF-8 en la base de datos, y pueden ser escapados como \uD###\uD### (el resultado de pares de sustitutos no válidos que se escapan o de pares de sustitutos no emparejados no está definido); estos pares de sustitutos válidos que se escapan se convertirán internamente en secuencias codificadas en UTF-8 de 4 bytes (en los planos suplementarios 1 a 16); los caracteres de los últimos planos suplementarios válidos 15 y 16, asignados solo para uso privado, son compatibles pero no útiles en los datos de OSM, ya que no son interoperables.

En general, no hay soporte actualmente para la sintaxis de escape común \U000##### que se usa en C moderno para representar un punto de código en cualquiera de los 17 planos Unicode válidos (excluyendo los sustitutos), y ni siquiera para los arbitrarios bytes de 8 bits con la sintaxis de escape común \x## (definida en C independientemente de la codificación empleada). Debe evitarse en lo posible el escape si no se necesita, y usar directamente UTF-8 válido en las solicitudes.

A partir de julio de 2017, la instancia de desarrollo de la API de Overpass permite el uso de expresiones ICU regulares, que soportan escapes \\U000#####. El soporte de la UCI en este punto final es experimental. Las expresiones regulares de la UCI no son, y puede que nunca sean, parte de la API oficial de Overpass. Esta característica puede ser descontinuada en cualquier momento sin previo aviso. Para habilitar esta funcionalidad, usa el ajuste [regexp:ICU]; como parte de tu declaración de ajustes, y usa el punto final de la API de desarrollo en http://dev.overpass-api.de/api_mmd/. Si estás usando la interfaz del Overpass Turbo, debes añadir {{data:overpass,server=http://dev.overpass-api.de/api_mmd/}} de las consultas de Overpass Turbo extendidas al final de tu código para usar la instancia de desarrollo de la API de Overpass API. Con esta adición, se reconocen otros escapes ICU soportados (usando dobles barras invertidas en las expresiones regulares de Overpass QL), incluyendo \\p{Unicode property name}, que coincidirá con cualquier carácter Unicode que tenga la propiedad Unicode especificada. Existe una consulta de ejemplo que encuentra caracteres CJK fuera del Plano Básico Multilingüe. Véase la entrada de blog(en) y el hilo de seguimiento en GitHub de esta funcionalidad potencial.

Otras características

Mapear vía/relación al área (map_to_area)

La declaración map_to_area mapea los identificadores de objetos OSM tanto para vías como para relaciones con su contraparte del identificador del área de la API de Overpass.

Esto se hace aplicando las siguientes reglas de mapeo dentro de la API de Overpass:

  • Para vías: se añade 2400000000 al identificador OSM de la vía
  • Para relaciones: se añade 3600000000 al identificador OSM de la relación

Ejemplo:

  rel(62716);
  out;              // da como resultado la relación 62716
  map_to_area;      // mapea la relación de OSM con el área de la API de Overpass añadiendo 3600000000 a su identificador
  out;              // da como resultado el área de salida 3600062716

El caso de uso principal de esta declaración es la búsqueda de objetos dentro de un área, que a su vez se encuentra dentro de otra área («búsqueda de área en área»).

Notas:

  • El trabajo de creación del área interna de la API de Overpass no crea un área para todas y cada una de las vías/relaciones en OSM. Si un área no existe para una vía/relación determinada, 'map_to_area' simplemente saltará este objeto sin añadir un área. De lo contrario, el área será devuelta pero con su geometría tal como estaba cuando fue creada o actualizada por última vez por un proceso de base interno en el servidor de Overpass, y puede ser diferente de la geometría más reciente cargada del elemento vía/relación en la base de datos de OSM.
  • El uso de áreas en consultas en lugar de elementos reales de OSM puede acelerar las consultas de Overpass, ya que estas geometrías no necesitan ser cargadas completamente a partir de los posiblemente muchos elementos hijos de la base de datos de OSM, y luego convertidas conectando las vías con nodos comunes.
  • Además, no todas las relaciones y vías pueden convertirse en un área válida (incluso si sus etiquetas normalmente implican que deben ser áreas válidas) si no crean anillos correctamente cerrados.
  • Véase también: API de Overpass/Áreas

Los siguientes ejemplos esbozan algunos posibles casos de uso para esta declaración:

Ejemplo 1: Encontrar todos los pubs en el interior de la ciudad de Colonia (Köln)

Al realizar la consulta solo para una zona llamada «Innenstadt» se obtendría un buen número de zonas, que no se limitan a Colonia.

try it yourself in overpass-turbo
area[name="Köln"]->.b;
rel(area.b)[name="Innenstadt"];
map_to_area -> .a;
node(area.a)[amenity=pub];
out meta;

Ejemplo 2: Encontrar todos los municipios (admin_level=8) en Hessen sin estación de bomberos

try it yourself in overpass-turbo
area[admin_level=4]["name"="Hessen"][boundary=administrative]->.boundaryarea;
( node(area.boundaryarea)["amenity"="fire_station"];
  way(area.boundaryarea)["amenity"="fire_station"];
  >;
) ->.a;

.a is_in -> .b; 
area.b[admin_level=8] -> .bf; 

rel(area.boundaryarea)[admin_level=8];
map_to_area -> .bllf;

(.bllf; - .bf; );
rel(pivot);
(._;>;);
out;

Ejemplo 3ː Contar el número de farmacias por condado

try it yourself in overpass-turbo
[out:csv(::"type",::"id", name, admin_level,::"count")];
area[name="Saarland"][boundary];
 rel(area)[boundary][admin_level=6];
 map_to_area;
 foreach->.d(
   (.d;);out; 
   (node(area.d)[amenity=pharmacy];
    way(area.d)[amenity=pharmacy];
    relation(area.d)[amenity=pharmacy];);
   out count;
 );

Ejemplo 4ː Conjunto de entrada designado

try it yourself in overpass-turbo
rel(62716)->.b;
  .b out;
  .b map_to_area;
  out;

Notas

Véase también