testListSnapshot: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var objects = realm.objects('TestObject');
var array;
realm.write(function() {
var obj = realm.create('LinkTypesObject', [[1], [2], [[3], [4]]]);
array = obj.arrayCol;
});
var objectsCopy = objects.snapshot();
var arrayCopy = array.snapshot();
TestCase.assertEqual(objectsCopy.length, 4);
TestCase.assertEqual(arrayCopy.length, 2);
realm.write(function() {
array.push([5]);
TestCase.assertEqual(objectsCopy.length, 4);
TestCase.assertEqual(arrayCopy.length, 2);
TestCase.assertEqual(objectsCopy.snapshot().length, 4);
TestCase.assertEqual(arrayCopy.snapshot().length, 2);
TestCase.assertEqual(objects.snapshot().length, 5);
TestCase.assertEqual(array.snapshot().length, 3);
realm.delete(array[0]);
TestCase.assertEqual(objectsCopy.length, 4);
TestCase.assertEqual(arrayCopy.length, 2);
TestCase.assertEqual(arrayCopy[0], null);
});
},
testListEnumerate: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var obj;
realm.write(function() {
obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: {doubleCol: 2},
arrayCol: [],
});
});
var index;
for (index in obj.arrayCol) {
TestCase.assertTrue(false, "No objects should have been enumerated: " + index);
}
realm.write(function() {
obj.arrayCol = [{doubleCol: 0}, {doubleCol: 1}];
TestCase.assertEqual(obj.arrayCol.length, 2);
});
var count = 0;
var keys = Object.keys(obj.arrayCol);
for (index in obj.arrayCol) {
TestCase.assertEqual(count++, +index);
TestCase.assertEqual(keys[index], index);
}
TestCase.assertEqual(count, 2);
TestCase.assertEqual(keys.length, 2);
},
testLinkTypesPropertySetters: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var objects = realm.objects('TestObject');
var obj;
realm.write(function() {
obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: null,
arrayCol: [{doubleCol: 3}],
});
});
TestCase.assertEqual(objects.length, 2);
TestCase.assertThrows(function() {
obj.objectCol1 = obj.objectCol;
}, 'can only set property values in a write transaction');
// set/reuse object property
realm.write(function() {
obj.objectCol1 = obj.objectCol;
});
TestCase.assertEqual(obj.objectCol1.doubleCol, 1);
//TestCase.assertEqual(obj.objectCol, obj.objectCol1);
TestCase.assertEqual(objects.length, 2);
realm.write(function() {
obj.objectCol = null;
obj.objectCol1 = null;
});
TestCase.assertEqual(obj.objectCol, null);
TestCase.assertEqual(obj.objectCol1, null);
// set object as JSON
realm.write(function() {
obj.objectCol = {doubleCol: 1};
});
TestCase.assertEqual(obj.objectCol.doubleCol, 1);
TestCase.assertEqual(objects.length, 3);
// set array property
realm.write(function() {
obj.arrayCol = [
obj.arrayCol[0],
obj.objectCol,
realm.create('TestObject', {doubleCol: 2}),
];
});
TestCase.assertEqual(objects.length, 4);
TestCase.assertEqual(obj.arrayCol.length, 3);
TestCase.assertEqual(obj.arrayCol[0].doubleCol, 3);
TestCase.assertEqual(obj.arrayCol[1].doubleCol, 1);
TestCase.assertEqual(obj.arrayCol[2].doubleCol, 2);
},
testNotifications: function() {
var realm = new Realm({schema: []});
var notificationCount = 0;
var notificationName;
realm.addListener('change', function(realm, name) {
notificationCount++;
notificationName = name;
});
TestCase.assertEqual(notificationCount, 0);
realm.write(function() {});
TestCase.assertEqual(notificationCount, 1);
TestCase.assertEqual(notificationName, 'change');
var secondNotificationCount = 0;
function secondNotification(realm, name) {
secondNotificationCount++;
}
// The listener should only be added once.
realm.addListener('change', secondNotification);
realm.addListener('change', secondNotification);
realm.write(function() {});
TestCase.assertEqual(notificationCount, 2);
TestCase.assertEqual(secondNotificationCount, 1);
realm.removeListener('change', secondNotification);
realm.write(function() {});
TestCase.assertEqual(notificationCount, 3);
TestCase.assertEqual(secondNotificationCount, 1);
realm.removeAllListeners();
realm.write(function() {});
TestCase.assertEqual(notificationCount, 3);
TestCase.assertEqual(secondNotificationCount, 1);
TestCase.assertThrows(function() {
realm.addListener('invalid', function() {});
});
realm.addListener('change', function() {
throw new Error('error');
});
TestCase.assertThrows(function() {
realm.write(function() {});
});
},
testLinkTypesPropertyGetters: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var obj = null;
realm.write(function() {
obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: null,
arrayCol: [{doubleCol: 3}],
});
});
var objVal = obj.objectCol;
TestCase.assertEqual(typeof objVal, 'object');
TestCase.assertNotEqual(objVal, null);
TestCase.assertEqual(objVal.doubleCol, 1);
TestCase.assertEqual(obj.objectCol1, null);
var arrayVal = obj.arrayCol;
TestCase.assertEqual(typeof arrayVal, 'object');
TestCase.assertNotEqual(arrayVal, null);
TestCase.assertEqual(arrayVal.length, 1);
TestCase.assertEqual(arrayVal[0].doubleCol, 3);
},
testListSorted: function() {
var realm = new Realm({schema: [schemas.PersonObject, schemas.PersonList]});
var list;
realm.write(function() {
var object = realm.create('PersonList', {list: [
{name: 'Ari', age: 10},
{name: 'Tim', age: 11},
{name: 'Bjarne', age: 12},
{name: 'Alex', age: 12, married: true}
]});
realm.create('PersonObject', {name: 'NotInList', age: 10});
list = object.list;
});
var names = function(results) {
return results.map(function(object) {
return object.name;
});
};
var objects = list.sorted('name', true);
TestCase.assertArraysEqual(names(objects), ['Tim', 'Bjarne', 'Ari', 'Alex']);
objects = list.sorted(['age', 'name']);
TestCase.assertArraysEqual(names(objects), ['Ari', 'Tim', 'Alex', 'Bjarne']);
},
testListLength: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var array;
realm.write(function() {
var obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: {doubleCol: 2},
arrayCol: [{doubleCol: 3}],
});
array = obj.arrayCol;
TestCase.assertEqual(array.length, 1);
obj.arrayCol = [];
TestCase.assertEqual(array.length, 0);
obj.arrayCol = [{doubleCol: 1}, {doubleCol: 2}];
TestCase.assertEqual(array.length, 2);
TestCase.assertThrows(function() {
array.length = 0;
}, 'cannot set length property on lists');
});
TestCase.assertEqual(array.length, 2);
},
testListShift: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var array;
realm.write(function() {
var obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: {doubleCol: 2},
arrayCol: [{doubleCol: 3}, {doubleCol: 4}],
});
array = obj.arrayCol;
TestCase.assertEqual(array.shift().doubleCol, 3);
TestCase.assertEqual(array.shift().doubleCol, 4);
TestCase.assertEqual(array.length, 0);
TestCase.assertEqual(array.shift(), undefined);
TestCase.assertThrows(function() {
array.shift(1);
});
});
TestCase.assertThrows(function() {
array.shift();
}, 'can only shift in a write transaction');
},
testListUnshift: function() {
var realm = new Realm({schema: [schemas.LinkTypes, schemas.TestObject]});
var array;
realm.write(function() {
var obj = realm.create('LinkTypesObject', {
objectCol: {doubleCol: 1},
objectCol1: {doubleCol: 2},
arrayCol: [{doubleCol: 3}],
});
array = obj.arrayCol;
TestCase.assertEqual(array.length, 1);
TestCase.assertEqual(array.unshift({doubleCol: 5}), 2);
TestCase.assertEqual(array.length, 2);
TestCase.assertEqual(array[0].doubleCol, 5);
TestCase.assertEqual(array.unshift(obj.objectCol, obj.objectCol1), 4);
TestCase.assertEqual(array.length, 4);
TestCase.assertEqual(array[0].doubleCol, 1);
TestCase.assertEqual(array[1].doubleCol, 2);
});
TestCase.assertEqual(array.length, 4);
TestCase.assertThrows(function() {
array.unshift({doubleCol: 1});
}, 'can only unshift in a write transaction');
},
testPropertiesOfData: () => {
const TestingSchema = {
name: 'Testing',
properties: {
n: 'int',
someData: 'data'
}
};
// Create a new realm
const realm = new Realm({schema: [TestingSchema]});
// Add a bunch of objects, with "data" to it
realm.write(() => {
for(let i = 0; i < NUMBER_OF_OBJECTS; i++) {
realm.create('Testing', {
n: i,
someData: new ArrayBuffer(BUFFER_LENGTH),
});
}
});
for (let readCycle = 0; readCycle < READ_CYCLES; readCycle++) {
let allObjects = realm.objects('Testing');
let totalBytes = 0;
for (let object of allObjects) {
let toBeFreed = object.someData;
// Accessing the byteLength of the objects someData property
totalBytes += toBeFreed.byteLength;
}
// console.log(`Read a total of ${totalBytes} bytes.`);
}
}
function writeCharacterToRealm(character: Character) {
realm.write(() => {
let realmobject = realm.create('Character', {
id: character.id,
name: character.name,
description: character.description,
wiki: character.wiki,
thumbnail: character.thumbnail,
portraitImg: character.portraitImg,
});
character.comics.map((item, index) => {
realmobject.comics.push(item);
});
character.series.map((item, index) => {
realmobject.series.push(item);
});
character.stories.map((item, index) => {
realmobject.stories.push(item);
});
character.events.map((item, index) => {
realmobject.events.push(item);
});
character.urls.map((item, index) => {
realmobject.urls.push(item);
});
});
}
function removePopularCharacter(char: Character) {
realm.write(() => {
var query = `id = "${char.id}"`;
let character = realm.objects('Character').filtered(query);
realm.delete(character);
});
}
export function clearRealmCache(objectName, idExclusions) {
try {
const objects = realmInstance.objects(objectName);
const expiredItems = [];
const excludedIds = [];
for (let i = 0; i < idExclusions.length; i++) {
excludedIds.push(idExclusions[i].id);
}
// Standard JS array.filter doesn't work with these Realm objects, so we have to take care of this filtering manually.
// Current version of Realm.io does not support exclusion queries for strings.
for (let i = objects.length - 1; i >= 0; i--) {
let expired = true;
for (let j = excludedIds.length - 1; j >= 0; j--) {
if (objects[i].id === excludedIds[j]) {
expired = false;
}
}
if (expired) {
expiredItems.push(objects[i]);
}
}
realmInstance.write(() => {
realmInstance.delete(expiredItems);
});
} catch (e) {
console.error(e);
}
}
testEnumerablePropertyNames: function() {
var realm = new Realm({schema: [schemas.BasicTypes]});
var object;
realm.write(function() {
object = realm.create('BasicTypesObject', {
boolCol: true,
intCol: 1,
floatCol: 1.1,
doubleCol: 1.11,
stringCol: 'string',
dateCol: new Date(1),
dataCol: RANDOM_DATA,
});
});
var propNames = Object.keys(schemas.BasicTypes.properties);
TestCase.assertArraysEqual(Object.keys(object), propNames, 'Object.keys');
for (var key in object) {
TestCase.assertEqual(key, propNames.shift());
}
TestCase.assertEqual(propNames.length, 0);
},
onPress={()=>{
realm.write(()=>{
let cars=realm.objects('Car');
let car=cars.filtered('id==3');
realm.delete(car);
})
}}
onPress={()=>{
realm.write(()=>{
//进行更新id=1的数据,drive修改成赵云
realm.create('Car',{id:1,drive:'赵云'},true);
ToastAndroid.show('表修改完成...',ToastAndroid.SHORT);
})
}}
testResultsInvalidation: function() {
var realm = new Realm({schema: [schemas.TestObject]});
realm.write(function() {
for (var i = 10; i > 0; i--) {
realm.create('TestObject', [i]);
}
});
var resultsVariants = [
realm.objects('TestObject'),
realm.objects('TestObject').filtered('doubleCol > 1'),
realm.objects('TestObject').filtered('doubleCol > 1').sorted('doubleCol'),
realm.objects('TestObject').filtered('doubleCol > 1').snapshot()
];
// test isValid
resultsVariants.forEach(function(objects) {
TestCase.assertEqual(objects.isValid(), true);
});
// close and test invalidated accessors
realm.close();
realm = new Realm({
schemaVersion: 1,
schema: [schemas.TestObject, schemas.BasicTypes]
});
resultsVariants.forEach(function(objects) {
TestCase.assertEqual(objects.isValid(), false);
TestCase.assertThrows(function() { objects[0]; });
TestCase.assertThrows(function() { objects.filtered('doubleCol < 42'); });
TestCase.assertThrows(function() { objects.sorted('doubleCol', true); });
TestCase.assertThrows(function() { objects.snapshot(); });
});
},
update: function(todo, callback) {
if (!callback) return;
repository.write(() => {
callback();
todo.updatedAt = new Date();
});
}
testRealmConstructorSchemaVersion: function() {
var defaultRealm = new Realm({schema: []});
TestCase.assertEqual(defaultRealm.schemaVersion, 0);
TestCase.assertThrows(function() {
new Realm({schemaVersion: 1});
}, "Realm already opened at a different schema version");
TestCase.assertEqual(new Realm().schemaVersion, 0);
TestCase.assertEqual(new Realm({schemaVersion: 0}).schemaVersion, 0);
var realm = new Realm({path: 'test1.realm', schema: [], schemaVersion: 1});
TestCase.assertEqual(realm.schemaVersion, 1);
// FIXME - enable once Realm exposes a schema object
//TestCase.assertEqual(realm.schema.length, 0);
realm.close();
// FIXME - enable once realm initialization supports schema comparison
// TestCase.assertThrows(function() {
// realm = new Realm({path: testPath, schema: [schemas.TestObject], schemaVersion: 1});
// }, "schema changes require updating the schema version");
realm = new Realm({path: 'test1.realm', schema: [schemas.TestObject], schemaVersion: 2});
realm.write(function() {
realm.create('TestObject', {doubleCol: 1});
});
TestCase.assertEqual(realm.objects('TestObject')[0].doubleCol, 1)
},
testRealmObjects: function() {
var realm = new Realm({schema: [schemas.PersonObject, schemas.DefaultValues, schemas.TestObject]});
realm.write(function() {
realm.create('PersonObject', {name: 'Ari', age: 10});
realm.create('PersonObject', {name: 'Tim', age: 11});
realm.create('PersonObject', {name: 'Bjarne', age: 12});
realm.create('PersonObject', {name: 'Alex', age: 12, married: true});
});
// Should be able to pass constructor for getting objects.
var objects = realm.objects(schemas.PersonObject);
TestCase.assertTrue(objects[0] instanceof schemas.PersonObject);
function InvalidPerson() {}
InvalidPerson.schema = schemas.PersonObject.schema;
TestCase.assertThrows(function() {
realm.objects();
});
TestCase.assertThrows(function() {
realm.objects([]);
});
TestCase.assertThrows(function() {
realm.objects('InvalidClass');
});
TestCase.assertThrows(function() {
realm.objects('PersonObject', 'truepredicate');
});
TestCase.assertThrows(function() {
realm.objects(InvalidPerson);
});
},
_deleteItem (name) {
let itemToDelete = favs.filtered('name = $0', name)
realm.write(() => {
realm.delete(itemToDelete)
})
this.forceUpdate()
}
_addItem () {
if (this.state.input === '') return
realm.write(() => {
realm.create('Categories', { name: this.state.input })
})
this.setState({ input: '' })
}
testDates: function() {
Realm.copyBundledRealmFiles();
// test file format upgrade
var realm_v3 = new Realm({path: 'dates-v3.realm', schema: [schemas.DateObject]});
TestCase.assertEqual(realm_v3.objects('Date').length, 2);
TestCase.assertEqual(realm_v3.objects('Date')[0].currentDate.getTime(), 1462500087955);
TestCase.assertEqual(realm_v3.objects('Date')[0].nullDate.getTime(), 1462500087955);
TestCase.assertEqual(realm_v3.objects('Date')[1].currentDate.getTime(), -10000);
TestCase.assertEqual(realm_v3.objects('Date')[1].nullDate, null);
// get new file format is not upgraded
var realm_v5 = new Realm({path: 'dates-v5.realm', schema: [schemas.DateObject]});
TestCase.assertEqual(realm_v5.objects('Date').length, 2);
TestCase.assertEqual(realm_v3.objects('Date')[0].currentDate.getTime(), 1462500087955);
TestCase.assertEqual(realm_v3.objects('Date')[0].nullDate.getTime(), 1462500087955);
TestCase.assertEqual(realm_v3.objects('Date')[1].currentDate.getTime(), -10000);
TestCase.assertEqual(realm_v3.objects('Date')[1].nullDate, null);
// test different dates
var realm = new Realm({schema: [schemas.DateObject]});
realm.write(function() {
realm.create('Date', { currentDate: new Date(10000) });
realm.create('Date', { currentDate: new Date(-10000) });
realm.create('Date', { currentDate: new Date(1000000000000) });
realm.create('Date', { currentDate: new Date(-1000000000000) });
});
TestCase.assertEqual(realm.objects('Date')[0].currentDate.getTime(), 10000);
TestCase.assertEqual(realm.objects('Date')[1].currentDate.getTime(), -10000);
TestCase.assertEqual(realm.objects('Date')[2].currentDate.getTime(), 1000000000000);
TestCase.assertEqual(realm.objects('Date')[3].currentDate.getTime(), -1000000000000);
}
].forEach(function(TypedArray) {
var array = new TypedArray(RANDOM_DATA.buffer);
realm.write(function() {
object.dataCol = array;
});
TestCase.assertArraysEqual(new TypedArray(object.dataCol), array, TypedArray.name);
});
].forEach(function(range) {
var array = RANDOM_DATA.subarray(range[0], range[1]);
realm.write(function() {
// Use a partial "view" of the underlying ArrayBuffer.
object.dataCol = new Uint8Array(RANDOM_DATA.buffer, range[0], array.length);
});
TestCase.assertArraysEqual(new Uint8Array(object.dataCol), array, range.join('...'));
});
const writeTransactionCreateCarAndPerson = () => {
let realm = new Realm({ schema: [Car, Person] });
realm.write(() => {
realm.create('Car', {
id: 1,
make: 'Honda',
model: 'Civic',
miles: 1000,
}, true);
});
realm.write(() => {
realm.create('Person', {
id: 1,
name: 'Charlie'
}, true);
});
}
save: function(todo) {
if (repository.objects('Todo').filtered("title = '" + todo.title + "'").length) return;
repository.write(() => {
todo.updatedAt = new Date();
repository.create('Todo', todo);
})
},
export const delContactLS = (obj) => {
realm.write(() => {
let rem = realm.objectForPrimaryKey(contactToAdd.schema.name, obj.numberValue)
console.log(rem)
realm.delete(rem)
})
}
_completeItem(id){
realm.write(() => {
var item = tasks.filtered('id = $0',id)[0]
item.completed = !item.completed
let data = this.getData(this.props.visibility)
this._updateData(data)
})
}
onPress={()=>
realm.write(()=>{
realm.create('Car',{id:1,name:'Benz',model:'C350',drive:'张三'});
realm.create('Car',{id:2,name:'Benz',model:'E250',drive:'李四'});
realm.create('Car',{id:3,name:'BMW',model:'740Li',drive:'王五'});
realm.create('Car',{id:4,name:'Mazda',model:'CX-5',drive:'赵六'});
realm.create('Car',{id:5,name:'大众',model:'辉腾',drive:'张飞'});
ToastAndroid.show('添加数据完成...',ToastAndroid.SHORT);
})