Tipos de datos - Flutter SDK

@RealmModel()
class _Player {
  @PrimaryKey()
  late ObjectId id;
  late String username;
  // `inventory` property of type RealmList<Item>
  // where Items are other RealmObjects
  late List<_Item> inventory;
  // `traits` property of type RealmList<String>
  // where traits are Dart Strings.
  late List<String> traits;
}
@RealmModel()
class _Item {
  @PrimaryKey()
  late ObjectId id;
  late String name;
  late String description;
}

final artemis =
    realm.write(() => realm.add(Player(ObjectId(), 'Art3mis', inventory: [
          Item(ObjectId(), 'elvish sword', 'sword forged by elves'),
          Item(ObjectId(), 'body armor', 'protects player from damage'),
        ], traits: [
          'brave',
          'kind'
        ])));
// Get a RealmList by property name with dynamic.getList()
final inventory = artemis.dynamic.getList('inventory');
// Use RealmList methods to filter results
RealmList<String> traits = artemis.traits;
final brave = traits.firstWhere((element) => element == 'brave');
final elvishSword =
    artemis.inventory.where((item) => item.name == 'elvish sword').first;
// Query RealmList with Realm Query Language
final playersWithBodyArmor =
    realm.query<Player>("inventory.name == \$0", ['body armor']);
print("LEN ${playersWithBodyArmor.length}");

@RealmModel()
class _RealmSetExample {
  late Set<String> primitiveSet;
  late Set<int?> nullablePrimitiveSet;
  late Set<_SomeRealmModel> realmObjectSet;
}
@RealmModel()
class _SomeRealmModel {
  late ObjectId id;
}

final realm = Realm(
    Configuration.local([RealmSetExample.schema, SomeRealmModel.schema]));
// Pass native Dart Sets to the object to create RealmSets
final setExample = RealmSetExample(
    primitiveSet: {'apple', 'pear'},
    nullablePrimitiveSet: {null, 2, 3},
    realmObjectSet: {SomeRealmModel(ObjectId())});
// Add RealmObject to database
realm.write(() => realm.add(setExample));
// Once you add the sets, they are of type RealmSet
RealmSet primitiveSet = setExample.primitiveSet;
// Modify RealmSets of RealmObjects in write transactions
realm.write(() {
  // Add element to a RealmSet with RealmSet.add()
  setExample.realmObjectSet.add(SomeRealmModel(ObjectId()));
  // Remove element from a RealmSet with RealmSet.remove()
  setExample.primitiveSet.remove('pear');
});
// Check if a RealmSet contains an element with RealmSet.contains()
if (setExample.primitiveSet.contains('apple')) {
  print('Set contains an apple');
}
// Get RealmSet by property name with dynamic.getSet()
final getSetResult = setExample.dynamic.getSet('primitiveSet');
// Check number of elements in a RealmSet with RealmSet.length
print(
    'Set now has ${getSetResult.length} elements'); // Prints 'Set now has 1 elements'
// Query RealmSets using Realm Query Language
final results =
    realm.query<RealmSetExample>('\$0 IN nullablePrimitiveSet', [null]);

@RealmModel()
class _MapExample {
  late Map<String, int> map;
  late Map<String, int?> nullableMap;
}

final realm = Realm(Configuration.local([MapExample.schema]));
// Pass native Dart Maps to the object to create RealmMaps
final mapExample = MapExample(
  map: {
    'first': 1,
    'second': 2,
    'third': 3,
  },
  nullableMap: {
    'first': null,
    'second': 2,
    'third': null,
  },
);
// Add RealmObject to the database
realm.write(() => realm.add(mapExample));
// Once you add maps, they are of type RealmMap
RealmMap map = mapExample.map;
// Modify RealmMaps in write transactions
realm.write(() {
  // Update value by key with .update() or [value] = newValue
  mapExample.nullableMap['second'] = null;
  mapExample.map.update('first', (value) => 5);
  mapExample.nullableMap.update('fourth', (v) => 4, ifAbsent: () => null);
  // Add a new map entry with .addEntries()
  const newMap = {'fourth': 4};
  mapExample.map.addEntries(newMap.entries);
});
// Check a RealmMap with .containsKey() or .containsValue()
if (mapExample.map.containsKey('first')) {
  print('Map contains key "first"');
} else if (mapExample.map.containsValue(null)) {
  print('Map contains null value');
} else {
  print('These aren\'t the maps you\'re looking for');
}
// Get a RealmMap by property name with dynamic.getMap()
final getPrimitiveMap = mapExample.dynamic.getMap('map');
// Check the number of elements in a RealmMap with RealmMap.length
print(
    'Map contains ${getPrimitiveMap.length} elements'); // Prints 'Map contains 4 elements'
// Query RealmMaps using Realm Query Language
final results = realm.query<MapExample>('map.first == \$0', [5]);

@RealmModel()
class _RealmValueExample {
  @Indexed()
  late RealmValue singleAnyValue;
  late List<RealmValue> listOfMixedAnyValues;
  late Set<RealmValue> setOfMixedAnyValues;
  late Map<String, RealmValue> mapOfMixedAnyValues;
}

final realm = Realm(Configuration.local([RealmValueExample.schema]));
realm.write(() {
  // Use 'RealmValue.from()' to set values
  var anyValue = realm.add(RealmValueExample(
      // Add a single `RealmValue` value
      singleAnyValue: RealmValue.from(1),
      // Add a list of `RealmValue` values
      listOfMixedAnyValues: [Uuid.v4(), 'abc', 123].map(RealmValue.from),
      // Add a set of `RealmValue` values
      setOfMixedAnyValues: {
        RealmValue.from('abc'),
        RealmValue.from('def')
      },
      // Add a map of string keys and `RealmValue` values
      mapOfMixedAnyValues: {
        '1': RealmValue.from(123),
        '2': RealmValue.from('abc')
      }));
  // Use 'RealmValue.nullValue()' to set null values
  var anyValueNull = realm.add(RealmValueExample(
      singleAnyValue: RealmValue.nullValue(),
      listOfMixedAnyValues: [null, null].map(RealmValue.from),
      setOfMixedAnyValues: {RealmValue.nullValue()},
      mapOfMixedAnyValues: {'null': RealmValue.nullValue()}));

for (var obj in data) {
  for (var mixedValue in obj.listOfMixedAnyValues) {
    // Use RealmValue.value to access the value
    final value = mixedValue.value;
    if (value is int) {
      sum = sum + value;
    } else if (value is String) {
      combinedStrings += value;
    }
    // Use RealmValue.as<T> to cast value to a specific type
    try {
      final intValue = mixedValue.as<int>();
      sum = sum + intValue;
    } catch (e) {
      log('Error casting value to int: $e');
    }
  }
}

final data = realm.all<RealmValueExample>();
for (var obj in data) {
  final anyValue = obj.singleAnyValue;
  // Access the RealmValue.type property
  switch (anyValue.type) {
    // Work with the returned RealmValueType enums
    case RealmValueType.int:
      approximateAge = DateTime.now().year - anyValue.as<int>();
      break;
    case RealmValueType.dateTime:
      approximateAge =
          (DateTime.now().difference(anyValue.as<DateTime>()).inDays /
                  365)
              .floor();
      break;
    case RealmValueType.string:
      final birthday = DateTime.parse(anyValue.as<String>());
      approximateAge =
          (DateTime.now().difference(birthday).inDays / 365).floor();
      break;
    // Handle other possible types ...
    default:
      log('Unhandled type: ${anyValue.type}');
  }
}

realm.write(() {
  realm.add(RealmValueCollectionExample(
      // Set the RealmValue as a map of mixed data
      singleAnyValue: RealmValue.from({
    'int': 1,
    // You can nest RealmValues in collections
    'listOfInt': [2, 3, 4],
    'mapOfStrings': {'1': 'first', '2': 'second'},
    // You can also nest collections within collections
    'mapOfMaps': [
      {
        'nestedMap_1': {'1': 1, '2': 2},
        'nestedMap_2': {'3': 3, '4': 4}
      }
    ],
    'listOfMaps': [
      {
        'nestedList_1': [1, 2, 3],
        'nestedList_2': [4, 5, 6]
      }
    ]
  })));