Lektion 28: Aktualisierung großer Datensätze

Manchmal müssen wir Tausende von Ressourcen in einer einzigen Aktion aktualisieren, wie es im folgenden Kommentar (gepostet in einer Community-Gruppe über WordPress) zum Ausdruck kommt:

Ich stelle fest, dass ich bei vielen Kunden mit großen Datensätzen arbeite (10.000+ Produktvarianten für 1 Produkt oder 13.000+ Mediendateien) ... die Kunden wollen unweigerlich viele Dinge auf einmal in großen Mengen bearbeiten können – zum Beispiel 2.000 Mediendateien mit demselben Tag versehen.

In dieser Tutorial-Lektion erkunden wir Möglichkeiten, diese Aufgabe anzugehen.

Nested Mutations

Damit diese GraphQL-query funktioniert, muss die Schema-Konfiguration, die auf den Endpunkt angewendet wird, Nested Mutations aktiviert haben

Dank Nested Mutations können wir Tausende von Ressourcen aus der DB über eine einzige GraphQL-query abrufen und aktualisieren:

mutation ReplaceOldWithNewDomainInPosts {
  posts(pagination: { limit: 3000 }) {
    id
    rawContent
    adaptedRawContent: _strReplace(
      search: "https://my-old-domain.com"
      replaceWith: "https://my-new-domain.com"
      in: $__rawContent
    )
    update(input: {
      contentAs: { html: $__adaptedRawContent }
    }) {
      status
      errors {
        __typename
        ...on ErrorPayload {
          message
        }
      }
    }
  }
}

Je nach Ausfallsicherheit des Systems kann diese einzelne GraphQL-Ausführung die DB jedoch zu stark belasten und sie sogar zum Absturz bringen.

Die Ausführung der GraphQL-query paginieren

Wenn das Aktualisieren von Tausenden von Ressourcen auf einmal das System zum Absturz bringt, ist die Lösung einfach: Anstatt die GraphQL nur einmal für Tausende von Ressourcen auszuführen, können wir sie hunderte von Malen für jeweils ein paar Dutzend Ressourcen ausführen.

Die folgenden Bash-Skripte ermitteln zunächst die Gesamtanzahl der Kommentare über commentCount, berechnen dann die Segmente unter Berücksichtigung der Umgebungsvariable $ENTRIES_TO_PROCESS, und berechnen die Paginierungsparameter und rufen die GraphQL-query für jedes Segment auf (wobei sie einfach die Kommentare aus diesem Segment abrufen):

# Get the number of comments in the site
GRAPHQL_RESPONSE=$(curl
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"query": "{\n  commentCount\n}"}' \
  https://mysite.com/graphql/)
 
# Extract the number of comments into a variable
COMMENT_COUNT=$(echo $GRAPHQL_RESPONSE \
  | grep -E -o '"commentCount\":([0-9]+)' \
  | cut -d':' -f2-)
 
echo "Number of comments: $COMMENT_COUNT"
 
# How many entries will be processed on each query
ENTRIES_TO_PROCESS=10
 
# Calculate how many requests must be triggered
PAGINATION_COUNT=$(($(($COMMENT_COUNT / $ENTRIES_TO_PROCESS)) + $(($(($COMMENT_COUNT % $ENTRIES_TO_PROCESS)) ? 1 : 0))))
 
echo "Number of requests to process (at $ENTRIES_TO_PROCESS entries per request): $PAGINATION_COUNT"
 
# Execute the requests, at one per second
for PAGINATION_NUMBER in $(seq 0 $(($PAGINATION_COUNT - 1))); do sleep 1 && echo "\n\nPagination number: $PAGINATION_NUMBER\n" && curl -X POST -H "Content-Type: application/json" -d "{\"query\": \"{ comments(pagination: { limit: $ENTRIES_TO_PROCESS, offset: $(($PAGINATION_NUMBER * $ENTRIES_TO_PROCESS)) }) { id date content } }\"}" https://mysite.com/graphql/ ; done

Die GraphQL-query rekursiv ausführen

Da die obige Lösung Bash-Skripting erfordert, muss sie über die CLI (oder ein Admin-Panel oder Tool) ausgeführt werden, was ihre Verwendung einschränkt.

Wir können dieselbe Logik in die GraphQL-query selbst replizieren, sodass wir sie bereits innerhalb von WordPress ausführen können (und sie sogar bereits als GraphQL Persisted Query speichern können).

Die folgende GraphQL-query führt sich selbst rekursiv aus. Beim ersten Aufruf:

Teilt sie die Gesamtanzahl der zu aktualisierenden Ressourcen in Segmente auf (berechnet anhand der bereitgestellten $limit-Variable)
Führt sie sich selbst über eine neue HTTP-Anfrage für jedes der Segmente aus (wobei der entsprechende $offset als Variable übergeben wird), sodass jeweils nur eine Teilmenge aller Ressourcen aktualisiert wird

Die GraphQL-query ist rekursiv, indem die HTTP-Anfragen auf dieselbe URL wie die aktuelle zeigen (zuzüglich der $offset-Variable für das jeweilige Segment), wobei wir die URL (sowie den Body, die Methode und die Header) aus der aktuellen HTTP-Anfrage abrufen (über die Erweiterung HTTP Request via Schema).

Das $async-Argument, das an _sendHTTPRequests übergeben wird, wurde auf false gesetzt, sodass die HTTP-Anfragen nacheinander ausgeführt werden. Zusätzlich ermöglicht die optionale Variable $delay, anzugeben, wie viele Millisekunden vor dem Senden jeder Anfrage gewartet werden soll.

Sobald alle Ressourcen aktualisiert wurden, erreicht die Ausführung der GraphQL-query das Ende und wird beendet:

# When first invoked, we do not pass variable `$offset`
# Then `$offset` is `null`, and dynamic variable `$executeQuery` will be `true`
query ExportExecute(
  $offset: Int
) {
  executeQuery: _notNull(value: $offset)
    @export(as: "executeQuery")
    @remove # Comment this directive to visualize output during development
}
 
# Only calculate the segments on the first invocation of the GraphQL query
query CalculateVars($limit: Int! = 10)
  @depends(on: "ExportExecute")
  @skip(if: $executeQuery)
{
  # Calculate the number of HTTP requests to be sent
  commentCount
  fractionalNumberExecutions: _floatDivide(number: $__commentCount, by: $limit)
    @remove # Comment this directive to visualize output during development
  numberExecutions: _floatCeil(number: $__fractionalNumberExecutions)
  
  # Generate a list of the offset
  arrayOffsets: _arrayPad(array: [], length: $__numberExecutions, value: null)
    @underEachArrayItem(
      passIndexOnwardsAs: "position"
    )
      @applyField(
        name: "_intMultiply"
        arguments: {
          multiply: $position
          with: $limit
        }
        setResultInResponse: true
      )
    @export(as: "offsets")
 
  # Vars needed to generate a list of the HTTP Request inputs,
  # with many of them retrieved from the current HTTP request data
  url: _httpRequestFullURL
    @export(as: "url")
    @remove # Comment this directive to visualize output during development
  method: _httpRequestMethod
    @export(as: "method")
    @remove # Comment this directive to visualize output during development
  headers: _httpRequestHeaders
    @remove # Comment this directive to visualize output during development
  headersInputList: _objectConvertToNameValueEntryList(
    object: $__headers
  )
    @export(as: "headersInputList")
    @remove # Comment this directive to visualize output during development
  body: _httpRequestBody
    @remove # Comment this directive to visualize output during development
  bodyJSONObject: _strDecodeJSONObject(string: $__body)
    @export(as: "bodyJSONObject")
    @remove # Comment this directive to visualize output during development
  bodyHasVariables: _propertyIsSetInJSONObject(
    object: $__bodyJSONObject,
    by: { key: "variables" }
  )
    @export(as: "bodyHasVariables")
    @remove # Comment this directive to visualize output during development
}
 
query GenerateVars
  @depends(on: ["ExportExecute", "CalculateVars"])
  @skip(if: $executeQuery)
{
  bodyJSON: _echo(value: $bodyJSONObject)
    @unless(condition: $bodyHasVariables)
      @objectAddEntry(
        key: "variables"
        value: {}
      )
    @export(as: "bodyJSON")
    @remove # Comment this directive to visualize output during development
}
 
# Generate all the HTTPRequestInput objects to send each of the HTTP requests
query GenerateRequestInputs(
  $timeout: Float,
  $delay: Int
)
  @depends(on: ["ExportExecute", "GenerateVars"])
  @skip(if: $executeQuery)
{
  # Generate a list of the HTTP Request inputs (without the offset)
  requestInputs: _echo(value: $offsets)
    @underEachArrayItem(
      passValueOnwardsAs: "requestOffset"
      affectDirectivesUnderPos: [1, 2]
    )
      @applyField(
        name: "_objectAddEntry",
        arguments: {
          object: $bodyJSON
          underPath: "variables"
          key: "offset"
          value: $requestOffset
        },
        passOnwardsAs: "itemJSON"
      )
      @applyField(
        name: "_echo",
        arguments: {
          value: {
            url: $url
            method: $method
            options: {
              headers: $headersInputList
              json: $itemJSON
              timeout: $timeout
              delay: $delay
            }
          }
        },
        setResultInResponse: true
      )
    @export(as: "requestInputs")
    @remove # Comment this directive to visualize output during development
}
 
# Execute all the generated URLs, either asynchronously or not
query ExecuteURLs
  @depends(on: ["ExportExecute", "GenerateRequestInputs"])
  @skip(if: $executeQuery)
{
  _sendHTTPRequests(
    async: false
    inputs: $requestInputs
  ) {
    statusCode
    contentType
    body
      @remove
    bodyJSON: _strDecodeJSONObject(string: $__body)
  }
}
 
# This is the actual execution of the query.
# In this case, it simply prints the time when it was executed,
# the provided query variables, and the comment IDs for that segment
query ExecuteQuery(
  $offset: Int
  $limit: Int! = 10
)
  @depends(on: "ExportExecute")
  @include(if: $executeQuery)
{
  executionTime: _httpRequestRequestTime
  queryVariables: _sprintf(string: "[$limit: %s, $offset: %s]", values: [$limit, $offset])
  comments(
    pagination: { limit: $limit, offset: $offset }
    sort: { order: ASC, by: ID }
  ) {
    id
  }
}
 
query ExecuteAll
  @depends(on: ["ExecuteURLs", "ExecuteQuery"])
{
  id
    @remove
}

Die Antwort lautet:

{
  "data": {
    "commentCount": 23,
    "numberExecutions": 3,
    "arrayOffsets": [
      0,
      10,
      20
    ],
    "_sendHTTPRequests": [
      {
        "statusCode": 200,
        "contentType": "application/json",
        "bodyJSON": {
          "data": {
            "executionTime": 1689814467,
            "queryVariables": "[$limit: 10, $offset: 0]",
            "comments": [
              { "id": 2 },
              { "id": 3 },
              { "id": 4 },
              { "id": 5 },
              { "id": 6 },
              { "id": 7 },
              { "id": 8 },
              { "id": 9 },
              { "id": 10 },
              { "id": 11 }
            ]
          }
        }
      },
      {
        "statusCode": 200,
        "contentType": "application/json",
        "bodyJSON": {
          "data": {
            "executionTime": 1689814468,
            "queryVariables": "[$limit: 10, $offset: 10]",
            "comments": [
              { "id": 12 },
              { "id": 13 },
              { "id": 16 },
              { "id": 17 },
              { "id": 18 },
              { "id": 19 },
              { "id": 20 },
              { "id": 21 },
              { "id": 22 },
              { "id": 23 }
            ]
          }
        }
      },
      {
        "statusCode": 200,
        "contentType": "application/json",
        "bodyJSON": {
          "data": {
            "executionTime": 1689814470,
            "queryVariables": "[$limit: 10, $offset: 20]",
            "comments": [
              { "id": 24 },
              { "id": 25 },
              { "id": 26 }
            ]
          }
        }
      }
    ]
  }
}

​Nested Mutations

​Die Ausführung der GraphQL-query paginieren

​Die GraphQL-query rekursiv ausführen

Nested Mutations

Die Ausführung der GraphQL-query paginieren

Die GraphQL-query rekursiv ausführen