What is idempotency? For NoSQL databases — what are their differences and where to choose what?

Idempotence is a property of an operation where performing it multiple times yields the same result as performing it once. For example, if a request to set a value in a database is repeated several times, the final state does not change after the first execution.

NoSQL databases differ from relational ones in that they do not use a strict table schema and are often optimized for horizontal scaling and high-speed read/write operations. The main types of NoSQL databases are:

• Document-oriented (MongoDB, CouchDB) — store data in JSON-like documents.
• Column-oriented (Cassandra, HBase) — optimized for working with large volumes of data by columns.
• Key-value (Redis, Riak) — simple key-value pairs, very fast.
• Graph (Neo4j) — for storing and processing graphs and relationships.

The choice depends on the task:

• If a flexible schema and complex document queries are needed — choose document-oriented.
• For analytics and large data volumes — column-oriented.
• For caching and fast operations — key-value.
• For working with networks and relationships — graph databases.

Example of an idempotent HTTP request in Go:

// Example of an idempotent PUT request to update a resource
func updateResource(id string, data []byte) error {
    req, err := http.NewRequest("PUT", "https://api.example.com/resource/"+id, bytes.NewReader(data))
    if err != nil {
        return err
    }
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("failed to update resource")
    }
    return nil
}