Definir la sintaxis del archivo de ruta

Análisis de valores nulos a partir de nombres de archivos

La Federación de Datos analiza automáticamente una cadena vacía ("") en lugar de un atributo en la ruta del archivo como valor nulo BSON para todos los tipos de atributo de la Federación de Datos de Atlas, excepto string. Con string, una cadena vacía podría representar un valor nulo BSON o una cadena vacía BSON. La Federación de Datos de Atlas no analiza ningún valor BSON para el tipo de atributo string. Esto evita agregar un valor BSON con un tipo conflictivo a los documentos leídos desde el almacén de datos.

/records/january/1.json
/records/february/1.json
/records//1.json
For the path ``/records/{month string}/*``, Data Federation does not add any
computed fields for the ``month`` attribute to documents generated
from the third record in the above store.

Análisis de números rellenados a partir de nombres de archivos

La ruta del archivo puede incluir valores numéricos rellenados con ceros a la izquierda. Para que la Federación de Datos analice correctamente los valores numéricos rellenados para tipos de atributos como int, epoch_millis y epoch_secs, especifique el número de dígitos del valor mediante expresiones regulares.

|--users
   |--001.json
   |--002.json
   ...

/users/{user_id int:\\d{3}}

Analizar un solo campo a partir del nombre del archivo

Considere un almacén de instancias de base de datos federada accountingArchive que contiene archivos cuyo nombre describe una fecha de factura. Por ejemplo, el nombre de archivo /invoices/1564671291998.json contiene las facturas con la marca de tiempo UNIX 1564671291998.

El siguiente objeto genera un databases campo invoiceDate al analizar el nombre del archivo como una marca de tiempo de UNIX:

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{invoiceDate epoch_millis}"
          }
        ]
      }
    ]
  }
]

La Federación de Datos añade el campo calculado y el valor a cada documento generado a partir del nombre de archivo. Los documentos generados a partir del nombre de archivo de ejemplo incluyen el campo invoiceDate: ISODate("2019-08-01T14:54:51Z"). Las consultas en el campo invoiceDate solo se pueden dirigir a los archivos que coincidan con el valor especificado.

Analizar varios campos a partir del nombre de archivo

Considere un almacén de instancias de base de datos federada accountingArchive que contiene archivos cuyo nombre describe el número y la fecha de una factura. Por ejemplo, el nombre de archivo /invoices/MONGO12345-1564671291998.json contiene la factura MONGODB12345 para la marca de tiempo UNIX 1564671291998.

El siguiente objeto databases genera:

• Un campo invoiceNumber analizando el primer segmento del nombre de archivo como una cadena.

• Un campo invoiceDate al analizar el segundo segmento del nombre del archivo como una marca de tiempo UNIX.

"databases" : [
  {
    "name": "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{invoiceNumber string}-{invoiceDate epoch_millis}"
          }
        ]
      }
    ]
  }
]

La federación de datos agrega los campos y valores calculados a cada documento generado a partir del nombre de archivo. Los documentos generados a partir del nombre de archivo de ejemplo incluyen los siguientes campos:

• invoiceNumber : "MONGODB12345"

• invoiceDate : ISODate("2019-08-01T14:54:51Z")

Las consultas que incluyen los campos y se pueden dirigir únicamente a aquellos archivos que coincidan con los invoiceNumber valores especificados.invoiceDate

Utilizar una expresión regular para analizar campos desde el nombre del archivo.

Considere un almacén de instancias de base de datos federada accountingArchive que contiene archivos cuyo nombre describe el número y la fecha de una factura. Por ejemplo, el nombre de archivo /invoices/MONGODB12345-20190102.json contiene la factura MONGODB12345 de la fecha 20190102.

El siguiente objeto databases genera:

• Un campo invoiceNumber analizando el primer segmento del nombre de archivo como una cadena

• Un campo year mediante el uso de una expresión regular para analizar solo los primeros 4 dígitos del segundo segmento del nombre de archivo como un int.

• Un campo month mediante el uso de una expresión regular para analizar solo los 2 dígitos siguientes del segundo segmento del nombre de archivo como un número entero.

• Un campo day mediante el uso de una expresión regular para analizar solo los 2 dígitos siguientes del segundo segmento del nombre de archivo como un número entero.

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{invoiceNumber string}-{year int:\\d{4}}{month int:\\d{2}}{day int:\\d{2}}"
          }
        ]
      }
    ]
  }
]

La federación de datos agrega los campos y valores calculados a cada documento generado a partir del nombre de archivo. Los documentos generados a partir del nombre de archivo de ejemplo incluyen los siguientes campos:

• invoiceNumber : "MONGODB12345"

• year : 2019

• month: 01

• day: 02

Las consultas que incluyen todos los campos generados se pueden orientar únicamente a aquellos archivos que coincidan con los valores especificados.

Identificar rangos de datos consultables a partir del nombre del archivo

Considere un almacén de instancias de base de datos federada accountingArchive que contiene archivos cuyo nombre describe el rango de datos que contiene. Por ejemplo, el nombre de archivo /invoices/1546367712000-1549046112000.json contiene facturas del período comprendido entre 2019-01-01 y 2019-01-02, con el rango de fechas representado en milisegundos transcurridos desde la época de UNIX.

El siguiente objeto databases identifica el rango de tiempo mínimo como el primer segmento del nombre del archivo y el rango de tiempo máximo como el segundo segmento del nombre del archivo:

"databases" : [
  {
    "name: "accounting",
    "collections" : [
      {
        "name: "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{min(invoiceDate) epoch_millis}-{max(invoiceDate) epoch_millis}"
          }
        ]
      }
    ]
  }
]

Cuando Data Federation recibe una consulta en el campo "invoiceDate", utiliza la ruta especificada para identificar qué archivos contienen los datos que coinciden con la consulta.

Las consultas en el campo invoiceDate se pueden dirigir únicamente a aquellos archivos cuyo rango capture el valor especificado, incluidas las fechas min y max.

Identificar campos anidados a partir del nombre del archivo

La federación de datos permite consultar datos anidados cuando el valor de estos también es el nombre del archivo. Puede usar el operador de punto (es. decir,) en su para asignar los atributos de las particiones de su configuración de almacenamiento a los campos anidados de sus path documentos.

Considere un almacén de instancias de base de datos federada accountingArchive. Este almacén contiene archivos cuyos nombres coinciden con los valores de los campos anidados en los documentos. Por ejemplo:

accountingArchive
|--invoices
   |--January.json
   |--February.json
   ...

Supongamos que el archivo January.json contiene un documento con los siguientes campos:

{
  "invoice": {
     "invoiceNumber" : "MONGODB12345",
     "year" : 2019,
     "month": "January", //value matches filename
     "date": 02
  },
  "vendor": "MONGODB",
  ...
}

El siguiente objeto databases identifica month como un campo anidado dentro de un documento. El objeto también identifica el valor databases de month como el nombre del archivo que contiene el documento.

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{invoice.month string}"
          }
        ]
      }
    ]
  }
]

Cuando Atlas Data Federation recibe una consulta sobre un mes específico, como January, utiliza la ruta especificada para identificar qué archivo contiene los datos que coinciden con la consulta.

Crear particiones a partir de ObjectIds

Puede especificar ObjectIds en la ruta de los archivos. Para los archivos que contienen ObjectId en el nombre, Atlas Data Federation crea particiones para ObjectId cada.

Considere el siguiente almacén de instancias de base de datos federada, accountingArchive. Este almacén de datos contiene archivos cuyo nombre incluye ObjectId:

accountingArchive
|--invoices
   |--507f1f77bcf86cd799439011.json
   |--507f1f77bcf86cd799439012.json
   |--507f1f77bcf86cd799439013.json
   |--507f1f77bcf86cd799439014.json
   |--507f1f77bcf86cd799439015.json

El siguiente objeto crea databases particiones ObjectIds para.

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{objid objectid}"
          }
        ]
      }
    ]
  }
]

O bien, supongamos que el almacén de instancias de base de datos federada accountingArchive contiene archivos cuyo nombre incluye un rango de ObjectIds. Por ejemplo:

accountingArchive
|--invoices
   |--507f1f77bcf86cd799439011-507f1f77bcf86cd799439020.json
   |--507f1f77bcf86cd799439021-507f1f77bcf86cd799439030.json
   |--507f1f77bcf86cd799439031-507f1f77bcf86cd799439040.json

El siguiente objeto crea particiones para el rango databases dado ObjectIds de.

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{min(obj) objectid}-{max(obj) objectid}"
          }
        ]
      }
    ]
  }
]

Cuando Data Federation recibe una consulta en ObjectId, utiliza la ruta especificada para identificar qué archivo contiene los datos que coinciden con la consulta.

Crear particiones a partir de la ruta del archivo

Puede especificar funciones de análisis en cualquier ruta que conduzca al nombre del archivo. Cada campo calculado se basa en una función de análisis a lo largo de la ruta. Al consultar los datos, Atlas Data Federation convierte cada campo calculado en una partición. Las particiones, que son sinónimo de subdirectorios, se utilizan para filtrar archivos con mayor precisión.

Considere un almacén de instancias de base de datos federada accountingArchive con la siguiente estructura de directorio:

invoices
|--MONGO12345
   |--2019
      |--01
         |--02

El siguiente objeto crea databases las invoiceNumber yearmonthparticiones,, y day con un pequeño conjunto de archivos filtrados:

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{invoiceNumber string}/{year int}/{month int:\\d{2}}/{day int:\\d{2}}/*"
          }
        ]
      }
    ]
  }
}

Crear particiones desde ISODate

Puede especificar ISODate en la ruta de los archivos. Para los archivos que contienen ISODate en el nombre, Atlas Data Federation crea particiones para ISODate cada.

Considere el siguiente almacén de instancias de base de datos federada, accountingArchive. Este almacén de datos contiene archivos cuyo nombre incluye ISODate:

accountingArchive
|--invoices
   |--01_02_2022_2301.json
   |--02_02_2022_2301.json
   |--03_02_2022_2301.json
   |--04_02_2022_2301.json
   |--05_02_2022_2301.json

El siguiente objeto crea particiones databases para.ISODate muestra path cómo usar expresiones regulares para el formato de fecha si esta no está en formato 3339 RFC.

"databases" : [
  {
    "name" : "accounting",
    "collections" : [
      {
        "name" : "invoices",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/creationDate isodate('01_02_2006_1504'):\\d{2}_\\d{2}_\\d{4}_\\d{4}.json"
          }
        ]
      }
    ]
  }
]

Para obtener más información sobre otros formatos admitidos, consulte Usar tipos de atributos de partición.

Generar nombres de colecciones dinámicas a partir de la ruta del archivo

Considere un almacén de instancias de base de datos federada accountingArchive con la siguiente estructura de directorio:

invoices
|--SuperSoftware
|--UltraSoftware
|--MegaSoftware

El siguiente objeto genera un nombre de colección dinámico a partir de la ruta del databases archivo:

"databases" : [
  {
    "name" : "invoices",
    "collections" : [
      {
        "name" : "*",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/invoices/{collectionName()}/"
          }
        ]
      }
    ]
  }
]

Cuando se aplica a la estructura de directorio de ejemplo, la ruta da como resultado las siguientes colecciones:

• SuperSoftware

• UltraSoftware

• MegaSoftware

O bien, considere una instancia de base de datos federada accountingArchive con los siguientes archivos:

/orders/MONGODB/invoices/January.json
/orders/MONGODB/purchaseOrders/January.json
/orders/MONGODB/invoices/February.json
...

El siguiente objeto genera un nombre de colección dinámico a partir de la ruta del databases archivo:

"databases" : [
  {
    "name" : "invoices",
    "collections" : [
      {
        "name" : "*",
        "dataSources" : [
          {
            "storeName" : "accountingArchive",
            "path" : "/orders/MONGODB/{collectionName()}/{invoiceMonth string}.json/"
          }
        ]
      }
    ]
  }
]

Cuando se aplica a los nombres de archivos de ejemplo, la ruta da como resultado las siguientes colecciones:

• invoices

• purchaseOrders