Zapisywanie danych

W tym dokumencie omawiamy 4 metody zapisywania danych na urządzeniu Firebase Realtime Database: ustawienie, aktualizacja, przesyłanie i obsługa transakcji.

Sposoby oszczędzania danych

ustawianie	zapisywać lub zastępować dane w określonej ścieżce, np. messages/users/<username>
update	aktualizować niektóre klucze na zdefiniowanej ścieżce bez zastępowania wszystkich danych;
push | wypychanie [in descriptive contexts]	Dodaj do listy danych w bazie danych. Za każdym razem, gdy dodasz nowy węzeł do listy, baza danych wygeneruje unikalny klucz, np. messages/users/<unique-user-id>/<username>
transakcja	Używaj transakcji podczas pracy ze złożonymi danymi, które mogą zostać uszkodzone przez jednoczesne aktualizacje.

Zapisywanie danych

Podstawowa operacja zapisu bazy danych to zbiór, który zapisuje nowe dane w określonym odwołaniu do bazy danych, zastępując wszystkie istniejące dane na tej ścieżce. Aby lepiej zrozumieć zestawy, utworzymy prostą aplikację do blogowania. Dane Twojej aplikacji są przechowywane w tej referencji bazy danych:

Java

final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog");

Node.js

// Import Admin SDK
const { getDatabase } = require('firebase-admin/database');

// Get a database reference to our blog
const db = getDatabase();
const ref = db.ref('server/saving-data/fireblog');

Python

# Import database module.
from firebase_admin import db

# Get a database reference to our blog.
ref = db.reference('server/saving-data/fireblog')

Go

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our blog.
ref := client.NewRef("server/saving-data/fireblog")

Zacznijmy od zapisania danych użytkowników. Każdego użytkownika będziemy przechowywać pod unikalną nazwą użytkownika, a także jego imię i nazwisko oraz datę urodzenia. Każdy użytkownik ma unikalną nazwę użytkownika, więc warto użyć tutaj metody set zamiast metody push, ponieważ masz już klucz i nie musisz go tworzyć.

Najpierw utwórz odwołanie do bazy danych z danymi użytkownika. Następnie użyj set() / setValue(), aby zapisać obiekt użytkownika w bazie danych z nazwą użytkownika, imieniem i nazwiskiem oraz datą urodzenia. Możesz przekazać ciąg znaków, liczbę, wartość logiczną, null, tablicę lub dowolny obiekt JSON. Podanie wartości null spowoduje usunięcie danych z określonej lokalizacji. W tym przypadku przekazujesz mu obiekt:

Java

public static class User {

  public String date_of_birth;
  public String full_name;
  public String nickname;

  public User(String dateOfBirth, String fullName) {
    // ...
  }

  public User(String dateOfBirth, String fullName, String nickname) {
    // ...
  }

}

DatabaseReference usersRef = ref.child("users");

Map<String, User> users = new HashMap<>();
users.put("alanisawesome", new User("June 23, 1912", "Alan Turing"));
users.put("gracehop", new User("December 9, 1906", "Grace Hopper"));

usersRef.setValueAsync(users);

Node.js

const usersRef = ref.child('users');
usersRef.set({
  alanisawesome: {
    date_of_birth: 'June 23, 1912',
    full_name: 'Alan Turing'
  },
  gracehop: {
    date_of_birth: 'December 9, 1906',
    full_name: 'Grace Hopper'
  }
});

Python

users_ref = ref.child('users')
users_ref.set({
    'alanisawesome': {
        'date_of_birth': 'June 23, 1912',
        'full_name': 'Alan Turing'
    },
    'gracehop': {
        'date_of_birth': 'December 9, 1906',
        'full_name': 'Grace Hopper'
    }
})

Go

// User is a json-serializable type.
type User struct {
	DateOfBirth string `json:"date_of_birth,omitempty"`
	FullName    string `json:"full_name,omitempty"`
	Nickname    string `json:"nickname,omitempty"`
}

usersRef := ref.Child("users")
err := usersRef.Set(ctx, map[string]*User{
	"alanisawesome": {
		DateOfBirth: "June 23, 1912",
		FullName:    "Alan Turing",
	},
	"gracehop": {
		DateOfBirth: "December 9, 1906",
		FullName:    "Grace Hopper",
	},
})
if err != nil {
	log.Fatalln("Error setting value:", err)
}

Gdy obiekt JSON jest zapisywany w bazie danych, jego właściwości są automatycznie mapowane na podkatalogi bazy danych w sposób zagnieżdżony. Jeśli teraz otworzysz adres URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/users/alanisawesome/full_name, zobaczysz wartość „Alan Turing”. Możesz też zapisać dane bezpośrednio w lokalizacji podrzędnej:

Java

usersRef.child("alanisawesome").setValueAsync(new User("June 23, 1912", "Alan Turing"));
usersRef.child("gracehop").setValueAsync(new User("December 9, 1906", "Grace Hopper"));

Node.js

const usersRef = ref.child('users');
usersRef.child('alanisawesome').set({
  date_of_birth: 'June 23, 1912',
  full_name: 'Alan Turing'
});
usersRef.child('gracehop').set({
  date_of_birth: 'December 9, 1906',
  full_name: 'Grace Hopper'
});

Python

users_ref.child('alanisawesome').set({
    'date_of_birth': 'June 23, 1912',
    'full_name': 'Alan Turing'
})
users_ref.child('gracehop').set({
    'date_of_birth': 'December 9, 1906',
    'full_name': 'Grace Hopper'
})

Go

if err := usersRef.Child("alanisawesome").Set(ctx, &User{
	DateOfBirth: "June 23, 1912",
	FullName:    "Alan Turing",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

if err := usersRef.Child("gracehop").Set(ctx, &User{
	DateOfBirth: "December 9, 1906",
	FullName:    "Grace Hopper",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

W obu powyższych przykładach – zapisywanie obu wartości jednocześnie w ramach obiektu i oddzielnie w miejscach podrzędnych – w Twojej bazie danych zostaną zapisane te same dane:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper"
    }
  }
}

Pierwszy przykład spowoduje wywołanie tylko 1 zdarzenia na klientach, którzy obserwują dane, natomiast drugi przykład wywoła 2 zdarzenia. Pamiętaj, że jeśli w węźle usersRef istnieją już dane, pierwsze podejście spowoduje ich zastąpienie, ale drugie tylko zmodyfikuje wartość każdego osobnego węzła podrzędnego, nie zmieniając pozostałych podrzędnych węzłów węzła usersRef.

Ustawienie wartości spowoduje zastąpienie danych w określonym miejscu, w tym wszystkich węzłów podrzędnych.

Aktualizowanie zapisanych danych

Jeśli chcesz zapisać dane w kilku elementach podrzędnych lokalizacji bazy danych jednocześnie, bez zastępowania innych węzłów podrzędnych, możesz użyć metody aktualizacji w ten sposób:

Java

DatabaseReference hopperRef = usersRef.child("gracehop");
Map<String, Object> hopperUpdates = new HashMap<>();
hopperUpdates.put("nickname", "Amazing Grace");

hopperRef.updateChildrenAsync(hopperUpdates);

Node.js

const usersRef = ref.child('users');
const hopperRef = usersRef.child('gracehop');
hopperRef.update({
  'nickname': 'Amazing Grace'
});

Python

hopper_ref = users_ref.child('gracehop')
hopper_ref.update({
    'nickname': 'Amazing Grace'
})

Go

hopperRef := usersRef.Child("gracehop")
if err := hopperRef.Update(ctx, map[string]interface{}{
	"nickname": "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating child:", err)
}

Spowoduje to zaktualizowanie danych Grace, aby zawierały jej pseudonim. Jeśli zamiast set here użyjesz update, zostanie usunięta zarówno full_name, jak i date_of_birth z hopperRef.

Firebase Realtime Database obsługuje też aktualizacje wielościeżkowe. Oznacza to, że za pomocą instrukcji update możesz teraz aktualizować wartości w kilku miejscach w bazie danych jednocześnie. To potężna funkcja, która pomaga denormalizować dane. Korzystając z aktualizacji wielościeżkowych, możesz dodać przezwiska do Grace i Alana w tym samym czasie:

Java

Map<String, Object> userUpdates = new HashMap<>();
userUpdates.put("alanisawesome/nickname", "Alan The Machine");
userUpdates.put("gracehop/nickname", "Amazing Grace");

usersRef.updateChildrenAsync(userUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome/nickname': 'Alan The Machine',
  'gracehop/nickname': 'Amazing Grace'
});

Python

users_ref.update({
    'alanisawesome/nickname': 'Alan The Machine',
    'gracehop/nickname': 'Amazing Grace'
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome/nickname": "Alan The Machine",
	"gracehop/nickname":      "Amazing Grace",
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Po tej aktualizacji dodano pseudonimy Alana i Grace:

{
  "users": {
    "alanisawesome": {
      "date_of_birth": "June 23, 1912",
      "full_name": "Alan Turing",
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "date_of_birth": "December 9, 1906",
      "full_name": "Grace Hopper",
      "nickname": "Amazing Grace"
    }
  }
}

Pamiętaj, że próba zaktualizowania obiektów przez zapisanie obiektów z dołączonymi ścieżkami spowoduje inne działanie. Zobaczmy, co się stanie, jeśli zamiast tego spróbujesz zaktualizować informacje o Grace i Alanie w ten sposób:

Java

Map<String, Object> userNicknameUpdates = new HashMap<>();
userNicknameUpdates.put("alanisawesome", new User(null, null, "Alan The Machine"));
userNicknameUpdates.put("gracehop", new User(null, null, "Amazing Grace"));

usersRef.updateChildrenAsync(userNicknameUpdates);

Node.js

const usersRef = ref.child('users');
usersRef.update({
  'alanisawesome': {
    'nickname': 'Alan The Machine'
  },
  'gracehop': {
    'nickname': 'Amazing Grace'
  }
});

Python

users_ref.update({
    'alanisawesome': {
        'nickname': 'Alan The Machine'
    },
    'gracehop': {
        'nickname': 'Amazing Grace'
    }
})

Go

if err := usersRef.Update(ctx, map[string]interface{}{
	"alanisawesome": &User{Nickname: "Alan The Machine"},
	"gracehop":      &User{Nickname: "Amazing Grace"},
}); err != nil {
	log.Fatalln("Error updating children:", err)
}

Spowoduje to inne działanie, a mianowicie zastąpienie całego węzła /users:

{
  "users": {
    "alanisawesome": {
      "nickname": "Alan The Machine"
    },
    "gracehop": {
      "nickname": "Amazing Grace"
    }
  }
}

Aktualizowanie danych zagnieżdżonych

W przypadku pojedynczej ścieżki klucza, np. alanisawesome, aktualizowane są tylko dane na pierwszym poziomie podrzędnym, a wszystkie dane przekazane poza pierwszy poziom podrzędny są traktowane jako operacja zbioru. Funkcja wielu ścieżek umożliwia korzystanie z dłuższych ścieżek (np. alanisawesome/nickname) bez nadpisywania danych. Dlatego pierwszy przykład różni się od drugiego.

Dodawanie wywołania zwrotnego po zakończeniu

Jeśli chcesz wiedzieć, kiedy Twoje dane zostały zapisane, możesz dodać funkcję zwrotną po zakończeniu w pakietach Node.js i Java Admin SDK. Zarówno metoda set, jak i update w tych pakietach SDK przyjmują opcjonalną funkcję zwrotną po zakończeniu, która jest wywoływana po zapisaniu danych w bazie danych. Jeśli wywołanie zakończy się niepowodzeniem z jakiegoś powodu, wywołanie zwrotne otrzyma obiekt błędu wskazujący, dlaczego wystąpił błąd. W pakietach Admin SDK w Pythonie i Go wszystkie metody zapisu są blokujące. Oznacza to, że metody zapisu nie zwracają żadnych danych, dopóki nie zostaną zapisane w bazie danych.

Java

DatabaseReference dataRef = ref.child("data");
dataRef.setValue("I'm writing data", new DatabaseReference.CompletionListener() {
  @Override
  public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) {
    if (databaseError != null) {
      System.out.println("Data could not be saved " + databaseError.getMessage());
    } else {
      System.out.println("Data saved successfully.");
    }
  }
});

Node.js

dataRef.set('I\'m writing data', (error) => {
  if (error) {
    console.log('Data could not be saved.' + error);
  } else {
    console.log('Data saved successfully.');
  }
});

Zapisywanie list danych

Podczas tworzenia list danych należy pamiętać, że większość aplikacji jest przeznaczona dla wielu użytkowników, i odpowiednio dostosować strukturę listy. Rozwijając powyższy przykład, dodajmy do aplikacji wpisy na blogu. Początkowo możesz chcieć użyć zbioru do przechowywania elementów z automatycznie zwiększającymi się indeksami całkowitymi, takimi jak:

// NOT RECOMMENDED - use push() instead!
{
  "posts": {
    "0": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "1": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

Push a Transakcja

Podczas pracy z listami danych push() zapewnia unikalny i chronologiczny klucz. Możesz mieć pokusę użycia transakcji do wygenerowania własnych kluczy, ale push jest znacznie lepszym wyborem. Transakcje są wolniejsze i bardziej złożone. Wymagają co najmniej 1 przesyłania żądania i odpowiedzi na serwer. Klucz wygenerowany przez funkcję „push()” na kliencie działa w trybie offline i jest zoptymalizowany pod kątem wydajności.

Jeśli użytkownik doda nowy post, zostanie on zapisany jako /posts/2. Ta metoda działałaby, gdyby posty dodawał tylko jeden autor, ale w Twojej aplikacji do blogowania wiele osób może dodawać posty w tym samym czasie. Jeśli 2 autorzy piszą do /posts/2 jednocześnie, jeden z postów zostanie usunięty przez drugiego.

Aby rozwiązać ten problem, klienci Firebase udostępniają funkcję push(), która generuje unikalny klucz dla każdego nowego podrzędnego. Dzięki unikatowym kluczom podrzędnym kilka klientów może dodawać podrzędne do tego samego miejsca w tym samym czasie bez obaw o konflikty podczas zapisu.

Java

public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

DatabaseReference postsRef = ref.child("posts");

DatabaseReference newPostRef = postsRef.push();
newPostRef.setValueAsync(new Post("gracehop", "Announcing COBOL, a New Programming Language"));

// We can also chain the two calls together
postsRef.push().setValueAsync(new Post("alanisawesome", "The Turing Machine"));

Node.js

const newPostRef = postsRef.push();
newPostRef.set({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});

// we can also chain the two calls together
postsRef.push().set({
  author: 'alanisawesome',
  title: 'The Turing Machine'
});

Python

posts_ref = ref.child('posts')

new_post_ref = posts_ref.push()
new_post_ref.set({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

# We can also chain the two calls together
posts_ref.push().set({
    'author': 'alanisawesome',
    'title': 'The Turing Machine'
})

Go

// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

postsRef := ref.Child("posts")

newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

if err := newPostRef.Set(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error setting value:", err)
}

// We can also chain the two calls together
if _, err := postsRef.Push(ctx, &Post{
	Author: "alanisawesome",
	Title:  "The Turing Machine",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

Unikalny klucz jest oparty na sygnaturze czasowej, więc elementy listy będą automatycznie uporządkowane chronologicznie. Firebase generuje unikalny klucz dla każdego wpisu na blogu, więc jeśli wielu użytkowników doda wpis w tym samym czasie, nie wystąpi konflikt zapisu. Dane w bazie danych wyglądają teraz tak:

{
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "gracehop",
      "title": "Announcing COBOL, a New Programming Language"
    },
    "-JRHTHaKuITFIhnj02kE": {
      "author": "alanisawesome",
      "title": "The Turing Machine"
    }
  }
}

W JavaScript, Pythonie i Go wzór wywołania funkcji push(), a następnie natychmiast wywołania funkcji set() jest tak powszechny, że pakiet SDK Firebase umożliwia ich połączenie przez przekazanie danych do ustawienia bezpośrednio do funkcji push() w następujący sposób:

Java

// No Java equivalent

Node.js

// This is equivalent to the calls to push().set(...) above
postsRef.push({
  author: 'gracehop',
  title: 'Announcing COBOL, a New Programming Language'
});;

Python

# This is equivalent to the calls to push().set(...) above
posts_ref.push({
    'author': 'gracehop',
    'title': 'Announcing COBOL, a New Programming Language'
})

Go

if _, err := postsRef.Push(ctx, &Post{
	Author: "gracehop",
	Title:  "Announcing COBOL, a New Programming Language",
}); err != nil {
	log.Fatalln("Error pushing child node:", err)
}

Pobieranie unikalnego klucza wygenerowanego przez push()

Wywołanie funkcji push() zwróci odwołanie do nowej ścieżki danych, której możesz użyć do uzyskania klucza lub ustawienia danych. Ten kod spowoduje uzyskanie tych samych danych co w przykładzie powyżej, ale teraz będziemy mieć dostęp do wygenerowanego niepowtarzalnego klucza:

Java

// Generate a reference to a new location and add some data using push()
DatabaseReference pushedPostRef = postsRef.push();

// Get the unique ID generated by a push()
String postId = pushedPostRef.getKey();

Node.js

// Generate a reference to a new location and add some data using push()
const newPostRef = postsRef.push();

// Get the unique key generated by push()
const postId = newPostRef.key;

Python

# Generate a reference to a new location and add some data using push()
new_post_ref = posts_ref.push()

# Get the unique key generated by push()
post_id = new_post_ref.key

Go

// Generate a reference to a new location and add some data using Push()
newPostRef, err := postsRef.Push(ctx, nil)
if err != nil {
	log.Fatalln("Error pushing child node:", err)
}

// Get the unique key generated by Push()
postID := newPostRef.Key

Jak widzisz, możesz pobrać wartość unikalnego klucza z elementu odniesienia push().

W następnej sekcji dotyczącej pobierania danych dowiesz się, jak odczytywać te dane z bazy danych Firebase.

Zapisywanie danych transakcyjnych

Podczas pracy ze złożonymi danymi, które mogą zostać uszkodzone przez jednoczesne modyfikacje, np. przyrostowe liczniki, pakiet SDK udostępnia operację transakcji.

W przypadku Java i Node.js operacja transakcji ma 2 funkcje wywołania zwrotnego: funkcję aktualizacji i opcjonalną funkcję wywołania zwrotnego po zakończeniu. W Pythonie i Go operacja transakcji jest blokująca i dlatego akceptuje tylko funkcję aktualizacji.

Funkcja update przyjmuje jako argument bieżący stan danych i powinna zwrócić nowy pożądany stan, który chcesz zapisać. Jeśli np. chcesz zwiększyć liczbę głosów pozytywnych pod konkretnym postem na blogu, musisz napisać taką transakcję:

Java

DatabaseReference upvotesRef = ref.child("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes");
upvotesRef.runTransaction(new Transaction.Handler() {
  @Override
  public Transaction.Result doTransaction(MutableData mutableData) {
    Integer currentValue = mutableData.getValue(Integer.class);
    if (currentValue == null) {
      mutableData.setValue(1);
    } else {
      mutableData.setValue(currentValue + 1);
    }

    return Transaction.success(mutableData);
  }

  @Override
  public void onComplete(
      DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) {
    System.out.println("Transaction completed");
  }
});

Node.js

const upvotesRef = db.ref('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes');
upvotesRef.transaction((current_value) => {
  return (current_value || 0) + 1;
});

Python

def increment_votes(current_value):
    return current_value + 1 if current_value else 1

upvotes_ref = db.reference('server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes')
try:
    new_vote_count = upvotes_ref.transaction(increment_votes)
    print('Transaction completed')
except db.TransactionAbortedError:
    print('Transaction failed to commit')

Go

fn := func(t db.TransactionNode) (interface{}, error) {
	var currentValue int
	if err := t.Unmarshal(&currentValue); err != nil {
		return nil, err
	}
	return currentValue + 1, nil
}

ref := client.NewRef("server/saving-data/fireblog/posts/-JRHTHaIs-jNPLXOQivY/upvotes")
if err := ref.Transaction(ctx, fn); err != nil {
	log.Fatalln("Transaction failed to commit:", err)
}

W powyższym przykładzie sprawdzamy, czy licznik ma wartość null, czy też nie został jeszcze zwiększony. Transakcje mogą być wywoływane z wartością null, jeśli nie została zapisana żadna wartość domyślna.

Gdyby powyższy kod został uruchomiony bez funkcji transakcji, a 2 klienci próbowali zwiększyć jego wartość jednocześnie, obaj zapisaliby wartość 1 jako nową wartość, co spowodowałoby zwiększenie o 1 zamiast o 2.

Funkcja transakcji jest wywoływana wielokrotnie

Obsługa transakcji jest wywoływana wielokrotnie i musi być w stanie obsługiwać dane null. Nawet jeśli w Twojej bazie danych są już dane, mogą one nie zostać zapisane w pamięci podręcznej lokalnie podczas wykonywania funkcji transakcji.

Połączenia sieciowe i zapisywanie offline

W przypadku Node.js i Java, jeśli klient utraci połączenie z internetem, aplikacja będzie nadal działać prawidłowo. Pakiety SDK Admin w Pythonie i Go wymagają połączenia z siecią, ponieważ do komunikacji z serwerem bazy danych używają interfejsu Firebase REST API. Wywoływanie operacji bazy danych w pakietach SDK Python lub Go Admin bez połączenia z internetem powoduje wyjątki.

Klienci Firebase Node.js i Java utrzymują własną wewnętrzną wersję wszystkich aktywnych danych. Gdy dane są zapisywane, są najpierw zapisywane w tej wersji lokalnej. Następnie klient synchronizuje te dane z bazą danych oraz z innymi klientami według zasady „najlepszego wysiłku”.

W rezultacie wszystkie zapisy w bazie danych będą wywoływać zdarzenia lokalne natychmiast, jeszcze przed zapisaniem jakichkolwiek danych w bazie danych. Oznacza to, że gdy tworzysz aplikację za pomocą Firebase, Twoja aplikacja będzie działać płynnie niezależnie od opóźnień w sieci lub połączenia z internetem.

Gdy połączenie zostanie przywrócone, otrzymamy odpowiedni zestaw zdarzeń, dzięki czemu klient „nadrobi zaległości” w stosunku do bieżącego stanu serwera bez konieczności pisania kodu niestandardowego.

Zabezpieczanie danych

Firebase Realtime Database zawiera język zabezpieczeń, który pozwala określić, którzy użytkownicy mają dostęp do odczytu i zapisu do różnych węzłów danych. Więcej informacji znajdziesz w artykule Bezpieczeństwo danych.