Übersicht

Ansichten können sekundäre Datenstrukturen in IBM® Cloudant® for IBM Cloud® sein, die Schlüssel/Wertpaare speichern, die von Dokumentattributen abgeleitet sind. Sie können zur Abfrage und Aggregation von Dokumentenprojektionen verwendet werden.

Sie dienen in erster Linie zwei Zwecken:

• Indizierung (Projektion): Verwenden Sie reine Kartenansichten, um Dokumente in neue Schlüsselbereiche zu projizieren. Dies ermöglicht ein effizientes Nachschlagen und Sortieren nach anderen Feldern als der Dokument-ID (z. B. E-Mail, Zeitstempel oder Kategorie).
• Aggregation und Analyse: Verwenden Sie die Ansichten von MapReduce, um Daten über Dokumente hinweg auszugeben und zu aggregieren, z. B. um Dokumente nach Typ zu zählen, Werte zu summieren oder Durchschnittswerte zu berechnen.

Wie Ansichten funktionieren

Ansichten werden in Entwurfsdokumenten definiert und bestehen aus:

• Eine Map-Funktion ( JavaScript ): Wird für jedes Dokument ausgeführt, um festzustellen, welche Attribute den Schlüssel und den Wert der Ansicht bilden. Eine Map-Funktion kann null, eine oder viele Zeilen pro Dokument ausgeben.
• Eine optionale Reduzierfunktion: Dient zum Aggregieren der ausgegebenen Werte und unterstützt Operationen wie Zählen, Summieren oder Mittelwertbildung.

Einmal erstellte Ansichten werden automatisch von IBM Cloudant gepflegt und aktualisiert, wenn sich Dokumente ändern.

Bei partitionierten Datenbanken können Ansichten auf einer einzigen Partition arbeiten, wenn options.partitioned im Entwurfsdokument auf true eingestellt ist.

Wann werden Ansichten verwendet?

Die Ansichten sind ideal für:

• Effiziente Nachschlagewerke und Bereichsabfragen für andere Dokumentattribute als die ID (z. B. Suche nach Dokumenten nach Kunden-E-Mail oder Bestellstatus).
• Abdeckende Indizes: Abfragen, die nur mit den Schlüssel-/Wertdaten der Ansicht erfüllt werden können, ohne dass vollständige Dokumente abgerufen werden müssen.
• Aggregierte Zusammenfassungen: Generieren Sie Summen, Durchschnittswerte oder Zählungen, die nach Schlüsseln gruppiert sind (z. B. Umsatz nach Jahr/Monat/Tag).
• Partielle Indizes: Enthält nur eine Teilmenge von Dokumenten (z. B. eine Liste nur der abgeschlossenen E-Commerce-Bestellungen).

Wann man Ansichten nicht verwenden sollte

Vermeiden Sie Ansichten für:

• Ad-hoc-Abfragen- verwenden Sie stattdessen Cloudant Search.
• Freitext- oder Platzhaltersuche- verwenden Sie stattdessen Cloudant Search.

Einfache Ansicht

Die einfachste Form einer Ansicht ist eine Zuordnungsfunktion ('map'-Funktion). Die Zuordnungsfunktion generiert Ausgabedaten, die eine Analyse (Zuordnung) der Dokumente darstellen, die in der Datenbank gespeichert sind.

Sie können beispielsweise herausfinden, welcher Benutzer die Onlineregistrierung ausgeführt hat und über eine verifizierte E-Mail für den Kontakt verfügt. Sie können diese Informationen finden, indem Sie jedes Dokument überprüfen und im Dokument nach einem Feld namens "email_verified" suchen und den Wert von "email" abrufen. Wenn das Feld vorhanden ist und den Wert „ true “ enthält, bedeutet dies, dass der Nutzer die Registrierung abgeschlossen hat und Sie ihn per E-Mail kontaktieren können. Wenn das Feld nicht vorhanden ist oder einen anderen Wert als true hat, hat der Benutzer die Registrierung nicht abgeschlossen.

Mithilfe der Funktion emit in einer Ansichtsfunktion ist es leicht, eine Liste als Antwort auf die Ausführung einer Abfrage unter Verwendung der Ansicht zu generieren. Die Liste besteht aus Schlüssel/Wert-Paaren, wobei der Schlüssel hilft, das jeweilige Dokument zu identifizieren, und der Wert jeweils die genaue Detailinformation liefert, die Sie wünschen. Die Liste enthält auch Metadaten wie die Anzahl der zurückgegebenen key:value-Paare.

Die Dokument-ID (_id) wird automatisch in die Ergebnisdatensätze für die Schlüssel/Wert-Paare (key:value) eingeschlossen. Die Dokument-ID (_id) wird eingeschlossen, um dem Client die Arbeit mit den Ergebnissen zu erleichtern.

Im folgenden Beispiel für eine einfache Ansicht wird eine Zuordnungsfunktion verwendet:

function(user) {
  if(user.email_verified === true) {
    emit(user.email, {name: user.name, email_verified: user.email_verified, joined: user.joined});
  }
}

Beispieldaten zur Veranschaulichung des Beispiels für eine einfache Ansicht:

[
    {
        "_id":"abc123",
        "name": "Bob Smith",
        "email": "bob.smith@aol.com",
        "email_verified": true,
        "joined": "2019-01-24T10:42:59.000Z"
    },
    {
        "_id":"abc125",
        "name": "Amelie Smith",
        "email": "amelie.smith@aol.com",
        "email_verified": true,
        "joined": "2020-04-24T10:42:59.000Z"
    }
]

Beispielantwort für die Ausführung der Abfrage mit der einfachen Ansicht:

{
  "total_rows": 2,
  "offset": 0,
  "rows": [
    {
      "id": "abc125",
      "key": "amelie.smith@aol.com",
      "value": {
        "name": "Amelie Smith",
        "email_verified": true,
        "joined": "2020-04-24T10:42:59.000Z"
      }
    },
    {
      "id": "abc123",
      "key": "bob.smith@aol.com",
      "value": {
        "name": "Bob Smith",
        "email_verified": true,
        "joined": "2019-01-24T10:42:59.000Z"
      }
    }
  ]
}

Beispiele für Zuordnungsfunktionen

Die Definition einer Ansicht in einem Entwurfsdokument erstellt auch einen Index auf der Basis der Schlüsselinformationen. Die Erstellung und Verwendung des Index erhöht die Geschwindigkeit des Zugriffs und der Suche oder der Auswahl von Dokumenten in der Ansicht erheblich.

In den folgenden Abschnitten wird die Indexierung mit einfachen und komplexen Schlüsseln sowie die Reduzierung von Funktionen beschrieben.

Ihre Indexierungsfunktionen funktionieren in einer Umgebung mit begrenztem Speicher, in der das Dokument einen Teil des in der Umgebung verwendeten Speichers darstellt. Die Größe des Stack und des Dokuments des Codes dürfen die Speichergröße nicht überschreiten. Die maximale Größe eines Dokuments beträgt 64 MB.

function(doc) {
  if (doc.name) {
    emit("name", doc.name);
  }
}

function(doc) {
  if (doc.friends) {
    for (friend in doc.friends) {
      emit(doc._id, { "_id": friend });
    }
  }
}

Nutzung des Wertes

Der zweite Parameter der Funktion emit einer Definition von MapReduce ist der "Wert", der zusammen mit dem Schlüssel im resultierenden Index gespeichert wird. Der Wert hat zwei Verwendungszwecke:

1. Bei reinen Auswahlansichten kann der Wert verwendet werden, um eine Teilmenge des Dokuments zu speichern, damit bei der Abfrage nicht ?include_docs=true verwendet werden muss. Dies kann zu einer Leistungssteigerung bei der Abfrage führen, allerdings auf Kosten eines größeren Indexes.
2. Bei Ansichten, die einen Reduzierer verwenden, enthält der Wert in der Regel eine einzelne numerische Größe, ein kleines Objekt mit festen Schlüsseln und numerischen Werten oder ein kurzes Array von Zahlen. Die numerischen Daten werden summiert (mit dem Reduzierer _sum) oder erzeugen statistische Daten mit dem Reduzierer _stats.

Einige Beispiele:

// create a view to allow selection of orders by year/month/day,
// where a subset of the document is projected into the view's value.
function(doc) {
  if (doc.type === 'order') {
    const minidoc = {
      customer_id: doc.customer_id,
      date: doc.date,
      status: doc.status
    }
    emit([doc.year, doc.month, doc.day], minidoc)
  }
}
// create a view, designed for the _sum reducer which contains
// one row per order, in year/month/day order where the value
// is the order's total in USD. This can be summed at query-time
// with optional grouping by year, year/month or year/month/day.
function(doc) {
  emit([doc.year, doc.month, doc.day], doc.order_total_usd)
}
// create a view, designed for the _sum reducer which contains
// one row per order, in year/month/day order where the value
// contains three numeric quantities (order total, tax and shipping)
// which will be summed at query-time with optional grouping by year,
// year/month or year/month/day.
function(doc) {
  const value = {
    total: doc.order_total_usd,
    tax: doc.tax_usd,
    shipping: doc.shipping_usd
  }
  emit([doc.year, doc.month, doc.day], value)
}
// create a view, designed for the _sum reducer which contains
// one row per order, with customer_id as the key. The numeric
// quantities are in array (order total and tax)  which will be
// summed at query-time with optional grouping by customer_id
function(doc) {
  emit(doc.customer_id, [doc.order_total_usd, doc.tax_usd])
}

Geben Sie keine Schlüssel mit hoher Kardinalität in den Wert einer Ansicht ein, wie z. B. order_id oder customer_id da dies zu einer Erweiterung des reduzierten Wertes einer Ansicht führt, anstatt zu einer Reduzierung. Solche Abfragen können sich verzögern oder von der Datenbank zurückgewiesen werden IBM Cloudant Dienstleistung. Bei numerischen Reduzierern sind Daten mit hoher Kardinalität in der Regel eine Komponente des "Schlüssels" einer Ansicht, während der "Wert" für numerische Daten reserviert ist.

Reduktionsfunktionen

Entwurfsdokumente, in denen options.partitioned auf den Wert true gesetzt ist, können keine angepassten JavaScript-Reduktionsfunktionen enthalten. Nur integrierte Reduktionsfunktionen sind zulässig.

{
    "views": {
        "getVerifiedEmails": {
            "map": "function(user) { if(user.email_verified === true) { emit(user.email); } }"
        }
    }
}

{
    "views": {
        "teamCount": {
            "map": "function(doc) { if (doc.email_verified === true) { emit(doc.team, doc.name); } }",
            "reduce": "_count"
        }
    }
}

{"rows":[
{"key":null,"value":10010}
]}

{"rows":[
{"key":"blue","value":1409},
{"key":"green","value":1439},
{"key":"indigo","value":1425},
{"key":"orange","value":1432},
{"key":"red","value":1414},
{"key":"violet","value":1443},
{"key":"yellow","value":1448}
]}

{"total_rows":10010,"offset":4273,"rows":[
{"id":"783173e102613c78d02a2b3304001642","key":"orange","value":"Bethel Lusk"},
{"id":"783173e102613c78d02a2b3304001b40","key":"orange","value":"Ethyl Dionne"},
{"id":"783173e102613c78d02a2b3304009c66","key":"orange","value":"Fredda Hendrix"},
{"id":"783173e102613c78d02a2b330401800d","key":"orange","value":"Bibi Page"},
{"id":"783173e102613c78d02a2b3304018ae7","key":"orange","value":"Marylou Lavender-Milton"}
]}

{
    "views": {
        "productPrices": {
            "map": "function(doc) {  emit(doc.type, { price: doc.price, tax: doc.tax }); }",
            "reduce": "_sum"
        }
    }
}

{"rows":[
    {"key":null,"value":{"price":144.97, "tax":7.32}}
]}

{"rows":[
    {"key":"kitchen","value":{"price":14.99,"tax":1.14}},
    {"key":"garden","value":{"price":129.98,"tax":6.18}}
]}

{
    "views": {
        "salesByDate": {
            "map": "function(doc) { emit(doc.date, [doc.price, doc.tax]); }",
            "reduce": "_stats"
        }
    }
}

{"rows":[
    {"key":"2025-01-01","value":[
        {"sum":14.99,"count":1,"min":14.99,"max":14.99,"sumsqr":224.7001},
        {"sum":1.14,"count":1,"min":1.14,"max":1.14,"sumsqr":1.2995}
    ]},
    {"key":"2025-01-02","value":[
        {"sum":129.98,"count":2,"min":29.99,"max":99.99,"sumsqr":10897.4002},
        {"sum":6.18,"count":2,"min":1.62,"max":4.56,"sumsqr":23.418}
    ]}
]}

{
  "views": {
    "estimateIpCount": {
      "map": "function (doc) {\n  emit(doc.ip, 1);\n}",
      "reduce": "_approx_count_distinct"
    }
  }
}

{"rows":[
{"key":null,"value":100528}
]}

{
    "views": {
        "bestScores": {
            "map": "function(doc) { emit(doc.user_id, doc.score); }",
            "reduce": "_top_3"
        }
    }
}

{"rows":[
  {"key":null,"value":[99,98,97]}
]}

{"rows":[
  {"key":"user082","value":[99,98,97]},
  {"key":"user291","value":[85,72,42]},
  {"key":"user452","value":[55,51,30]}
]}

{
    "views": {
        "latestReading": {
            "map": "function(doc) { emit([doc.deviceid, doc.timestamp], doc); }",
            "reduce": "_last"
        }
    }
}

{"rows":[
{"key":["A00"],"value":{"_id":"93117567370d41d091b8dd160a3adf3f","_rev":"1-bc05e93e592d5a5a18e240240b581a55","deviceid":"A00","reading":13.8986,"timestamp":"2025-03-26T04:44:08.917Z","status":"red"}},
{"key":["A01"],"value":{"_id":"c9f53ac9e4a8444487ed0eaa11dc1c78","_rev":"1-1fcf121c73db03e49bac4c1981518b19","deviceid":"A01","reading":59.8453,"timestamp":"2025-04-01T01:52:34.254Z","status":"green"}},
{"key":["A02"],"value":{"_id":"577b7108a8a1458f9a17194ed1da398a","_rev":"1-71d345a773ab31f35ceb998f3c107c41","deviceid":"A02","reading":2.6208,"timestamp":"2025-03-31T00:22:17.175Z","status":"green"}},
{"key":["A03"],"value":{"_id":"150839b1d363427496a4f4e2917b8b1d","_rev":"1-860a2ed5f1f48aa642495dfb21dff3ce","deviceid":"A03","reading":55.8677,"timestamp":"2025-03-22T10:15:57.890Z","status":"red"}},
{"key":["A04"],"value":{"_id":"d3317bdc1f7b4466ae6bf7a30ca9e328","_rev":"1-a58762532f6980ca5b06a8d01d113814","deviceid":"A04","reading":44.1822,"timestamp":"2025-03-23T10:56:10.639Z","status":"green"}},
{"key":["A05"],"value":{"_id":"946754d3762f44e297ca20d13bbceb5e","_rev":"1-41fa2bb3ef8782c90b28ee44628abeab","deviceid":"A05","reading":13.2874,"timestamp":"2025-03-27T13:59:04.723Z","status":"blue"}},
{"key":["A06"],"value":{"_id":"bbcd8a5c0ae948baae713a9fcb5262d5","_rev":"1-66883211ee20a0772374672aa175dc50","deviceid":"A06","reading":7.9525,"timestamp":"2025-04-01T15:13:04.305Z","status":"blue"}},
{"key":["A07"],"value":{"_id":"a600caccdb82400698b158ecebfaa6f2","_rev":"1-68975a8d7133a13c6cc8ae34d28ea1c6","deviceid":"A07","reading":89.4818,"timestamp":"2025-03-07T02:12:59.934Z","status":"blue"}},
{"key":["A08"],"value":{"_id":"be20bae911db4da685f891fd01e07d3a","_rev":"1-d69b559627cf01e80fe85ea2f54d2f4b","deviceid":"A08","reading":97.6739,"timestamp":"2025-03-29T13:46:31.689Z","status":"green"}},
{"key":["A09"],"value":{"_id":"96526e80f2ff48e89e9e42aa47abae24","_rev":"1-85e56901f7113d7d6ff8ba573c535eb3","deviceid":"A09","reading":26.1597,"timestamp":"2025-03-18T03:22:19.848Z","status":"blue"}}
]}

Angepasste Reduktionsfunktionen

Die meisten Kunden stellen fest, dass die integrierten Reduktionsfunktionen ausreichen, um Aggregationen für Schlüssel/Wert-Paare (key-value) von Ansichten durchzuführen, die von Zuordnungsfunktionen ausgegeben werden. In außergewöhnlichen Anwendungsfällen kann jedoch eine JavaScript-Reduktionsfunktion anstelle des Namens einer der integrierten Reduktionsfunktionen angegeben werden.

Benutzerdefinierte Reduktionsfunktionen sind viel langsamer und schwieriger zu warten als integrierte Reduktionsfunktionen. Prüfen Sie daher, ob ein Anwendungsfall mit einer integrierten Reduktionsfunktion erfüllt werden kann, bevor Sie eine benutzerdefinierte Funktion schreiben.

An Reduktionsfunktionen werden drei Argumente in der folgenden Reihenfolge übergeben:

• keys
• values
• rereduce

Wenn eine Ansicht eine angepasste JavaScript-Reduktionsfunktion enthält, wird diese zum Erstellen von Aggregatergebnissen für die Ansicht verwendet. An eine Reduktionsfunktion wird ein Satz von Zwischenwerten übergeben, die von der Funktion zu einem Einzelwert kombiniert werden. Eine Reduktionsfunktion muss als Eingabe Ergebnisse akzeptieren, die von der entsprechenden Zuordnungsfunktion ausgegeben werden, und Ergebnisse akzeptieren, die von der Reduktionsfunktion selbst zurückgegeben werden. Der letztere Fall wird als Rereduktion ("rereduce") bezeichnet.

Eine Beschreibung der Reduktionsfunktionen wird im folgenden Beispiel gezeigt.

Sehen Sie sich das folgende Beispiel einer angepassten Reduzierungsfunktion an:

function (keys, values, rereduce) {
  return sum(values);
}

Reduktionsfunktionen müssen zwei Fälle behandeln:

1. Wenn rereduce den Wert 'false' hat:

   • keys ist ein Array, dessen Elemente Arrays im Format [key, id] sind. Dabei ist key ein Schlüssel, der von der Zuordnungsfunktion ausgegeben wird, und id gibt das Dokument an, aus dem der Schlüssel generiert wurde. values ist ein Array der Werte, die für die entsprechenden Elemente in keys ausgegeben werden, z. B. reduce([ [key1,id1], [key2,id2], [key3,id3] ], [value1,value2,value3], false).

2. Wenn rereduce den Wert 'true' hat:

   • keys ist null.
   • Bei values handelt es sich um ein Array von Werten, die von vorherigen Aufrufen der Reduktionsfunktion zurückgegeben wurden, wie zum Beispiel: reduce(null, [intermediate1,intermediate2,intermediate3], true).

Reduktionsfunktionen müssen einen einzelnen Wert zurückgeben, der sich sowohl für das Feld value der endgültigen Ansicht als auch als Element des Arrays values, das an die Reduktionsfunktion übergeben wird, eignet.

Reduktionsfunktionen können oft so geschrieben werden, dass sie Reduktionsaufrufe ohne zusätzlichen Code bewältigen können, wie die Summenfunktion im vorherigen Beispiel. In solchen Fällen kann das Argument rereduce ignoriert werden.

Durch die Wiederübergabe der Ergebnisse der Funktion reduce an die Funktion reduce kann MapReduce die Analyse sehr großer Datasets in diskrete, parallele Tasks aufteilen, die wesentlich schneller ausgeführt werden können.

Wenn Sie die integrierte Reduktionsfunktion verwenden und die Eingabe ungültig ist, wird der Fehler builtin_reduce_error zurückgegeben. Ausführlichere Informationen zu dem Fehler werden im Feld reason zur Verfügung gestellt. Die ursprünglichen Daten, die den Fehler verursacht haben, werden im Feld caused_by zurückgegeben.

Beispiel für eine Antwort:

{
    "rows": [
        {
            "key": null,
            "value": {
                "error": "builtin_reduce_error",
                "reason": "The _sum function requires that map values be numbers, arrays of numbers, or objects. Objects can't be mixed with other data structures. Objects can be arbitrarily nested, if the values for all fields are themselves numbers, arrays of numbers, or objects.",
                "caused_by": [
                    {
                        "a": 1
                    },
                    {
                        "a": 2
                    },
                    {
                        "a": 3
                    },
                    {
                        "a": 4
                    }
                ]
            }
        }
    ]
}

Einschränkungen für Map- und Reduce-Funktionen

Im Folgenden werden Einschränkungen für Map- und Reduce-Funktionen beschrieben.

Ansichtendefinition speichern

Jede Ansicht ist eine JavaScript-Funktion. Ansichten werden in Entwurfsdokumenten gespeichert. Wenn Sie also eine Ansicht speichern wollen, speichert IBM Cloudant sie einfach in der Funktionsdefinition in einem Entwurfsdokument. Ein Entwurfsdokument kann wie jedes andere Dokument erstellt oder aktualisiert werden.

Um eine Ansichtsdefinition zu speichern, PUT den Inhalt der Ansichtsdefinition in ein _design Dokument.

Im folgenden Beispiel ist die Ansicht getVerifiedEmails als Mapfunktion definiert und im Feld views des Entwurfsdokuments verfügbar.

Verwenden Sie die Methode PUT, um eine Ansicht zu einem Entwurfsdokument hinzuzufügen:

PUT $SERVICE_URL/$DATABASE/_design/$DDOC HTTP/1.1
Content-Type: application/json

Das folgende Beispiel fügt eine neue getVerifiedEmails benannte View-Funktion zum allusers Entwurfsdokument mit View-Definition hinzu:

{
    "views": {
        "getVerifiedEmails": {
            "map": "function(user) { if(user.email_verified === true){ emit(doc.email, {name: user.name, email_verified: user.email_verified, joined: user.joined}) }}  "
        }
    }
}

Sehen Sie sich die Anforderungsbeispiele an:

curl -X PUT "$SERVICE_URL/users/_design/allusers" --data '{
  "views": {
    "getVerifiedEmails": {
      "map": "function(user) { if(user.email_verified === true){ emit(doc.email, {name: user.name, email_verified: user.email_verified, joined: user.joined}) }}"
    }
  }
}'

import com.ibm.cloud.cloudant.v1.Cloudant;
import com.ibm.cloud.cloudant.v1.model.DesignDocument;
import com.ibm.cloud.cloudant.v1.model.DesignDocumentViewsMapReduce;
import com.ibm.cloud.cloudant.v1.model.DocumentResult;
import com.ibm.cloud.cloudant.v1.model.PutDesignDocumentOptions;
import java.util.Collections;
Cloudant service = Cloudant.newInstance();
DesignDocumentViewsMapReduce emailViewMapReduce =
    new DesignDocumentViewsMapReduce.Builder()
        .map("function(user) { if(user.email_verified === true){ emit(doc.email,{name: user.name, email_verified: user.email_verified, joined: user.joined}) }")
        .build();
DesignDocument designDocument = new DesignDocument();
designDocument.setViews(
        Collections.singletonMap("getVerifiedEmails", emailViewMapReduce));
PutDesignDocumentOptions designDocumentOptions =
    new PutDesignDocumentOptions.Builder()
        .db("users")
        .designDocument(designDocument)
        .ddoc("allusers")
        .build();
DocumentResult response =
    service.putDesignDocument(designDocumentOptions).execute()
        .getResult();
System.out.println(response);

import { CloudantV1 } from '@ibm-cloud/cloudant';
const service = CloudantV1.newInstance({});
const emailViewMapReduce: CloudantV1.DesignDocumentViewsMapReduce = {
  map: 'function(user) { if(user.email_verified === true){ emit(doc.email, {name: user.name, email_verified: user.email_verified, joined: user.joined}) }}'
}
const designDocument: CloudantV1.DesignDocument = {
  views: {'getVerifiedEmails': emailViewMapReduce}
}
service.putDesignDocument({
  db: 'users',
  designDocument: designDocument,
  ddoc: 'allusers'
}).then(response => {
  console.log(response.result);
});

from ibmcloudant.cloudant_v1 import CloudantV1
service = CloudantV1.new_instance()
email_view_map_reduce = DesignDocumentViewsMapReduce(
  map='function(user) { if(user.email_verified === true){ emit(doc.email, {name: user.name, email_verified: user.email_verified, joined: user.joined}) }}'
)
design_document = DesignDocument(
  views={'getVerifiedEmails': email_view_map_reduce}
)
response = service.put_design_document(
  db='users',
  design_document=design_document,
  ddoc='allusers'
).get_result()
print(response)

emailViewMapReduce, err := service.NewDesignDocumentViewsMapReduce(
  "function(user) { if(user.email_verified === true){ emit(doc.email, {name: user.name, email_verified: user.email_verified, joined: user.joined}) }}",
)
if err != nil {
  panic(err)
}
designDocument := &cloudantv1.DesignDocument{
  Views: map[string]cloudantv1.DesignDocumentViewsMapReduce{
    "getVerifiedEmails": *emailViewMapReduce,
  },
}
putDesignDocumentOptions := service.NewPutDesignDocumentOptions(
  "users",
  "allusers",
  designDocument,
)
documentResult, _, err := service.PutDesignDocument(putDesignDocumentOptions)
if err != nil {
  panic(err)
}
b, _ := json.MarshalIndent(documentResult, "", "  ")
fmt.Println(string(b))

Das vorherige Go-Beispiel erfordert den folgenden Importblock:

import (
  "encoding/json"
  "fmt"
  "github.com/IBM/cloudant-go-sdk/cloudantv1"
)

Für alle Go-Beispiele muss das Objekt service initialisiert sein. Weitere Informationen finden Sie in den Beispielen im Abschnitt 'Authentifizierung' in der API-Dokumentation.