Examples with Decimal128 org.bson.types.Decimal128 used on opensource projects

Example 61 with Decimal128

use of org.bson.types.Decimal128 in project realm-java by realm.

the class RealmTests method populateTestRealm.

private void populateTestRealm(Realm realm, int objects) {
    realm.beginTransaction();
    realm.deleteAll();
    for (int i = 0; i < objects; ++i) {
        AllTypes allTypes = realm.createObject(AllTypes.class);
        allTypes.setColumnBoolean((i % 3) == 0);
        allTypes.setColumnBinary(new byte[] { 1, 2, 3 });
        allTypes.setColumnDate(new Date());
        allTypes.setColumnDouble(Math.PI);
        allTypes.setColumnFloat(1.234567F + i);
        allTypes.setColumnObjectId(new ObjectId(TestHelper.generateObjectIdHexString(i)));
        allTypes.setColumnDecimal128(new Decimal128(new BigDecimal(i + "12345")));
        allTypes.setColumnUUID(UUID.fromString(TestHelper.generateUUIDString(i)));
        allTypes.setColumnRealmAny(RealmAny.valueOf(UUID.fromString(TestHelper.generateUUIDString(i))));
        allTypes.setColumnString("test data " + i);
        allTypes.setColumnLong(i);
        NonLatinFieldNames nonLatinFieldNames = realm.createObject(NonLatinFieldNames.class);
        nonLatinFieldNames.set델타(i);
        nonLatinFieldNames.setΔέλτα(i);
        nonLatinFieldNames.set베타(1.234567F + i);
        nonLatinFieldNames.setΒήτα(1.234567F + i);
    }
    realm.commitTransaction();
}

Example 62 with Decimal128

use of org.bson.types.Decimal128 in project realm-java by realm.

the class JNIRowTest method nullValues.

@Test
public void nullValues() {
    Table table = TestHelper.createTable(sharedRealm, "temp");
    long colStringIndex = table.addColumn(RealmFieldType.STRING, "string", true);
    long colIntIndex = table.addColumn(RealmFieldType.INTEGER, "integer", true);
    table.addColumn(RealmFieldType.FLOAT, "float");
    table.addColumn(RealmFieldType.DOUBLE, "double");
    long colBoolIndex = table.addColumn(RealmFieldType.BOOLEAN, "boolean", true);
    table.addColumn(RealmFieldType.DATE, "date");
    table.addColumn(RealmFieldType.BINARY, "binary");
    long colDecimalIndex = table.addColumn(RealmFieldType.DECIMAL128, "decimal128", true);
    long colObjectIdIndex = table.addColumn(RealmFieldType.OBJECT_ID, "object_id", true);
    long rowIndex = OsObject.createRow(table);
    UncheckedRow row = table.getUncheckedRow(rowIndex);
    row.setString(colStringIndex, "test");
    assertEquals("test", row.getString(colStringIndex));
    row.setNull(colStringIndex);
    assertNull(row.getString(colStringIndex));
    row.setLong(colIntIndex, 1);
    assertFalse(row.isNull(colIntIndex));
    row.setNull(colIntIndex);
    assertTrue(row.isNull(colIntIndex));
    row.setBoolean(colBoolIndex, true);
    assertFalse(row.isNull(colBoolIndex));
    row.setNull(colBoolIndex);
    assertTrue(row.isNull(colBoolIndex));
    row.setDecimal128(colDecimalIndex, new Decimal128(0));
    assertFalse(row.isNull(colDecimalIndex));
    row.setNull(colDecimalIndex);
    assertTrue(row.isNull(colDecimalIndex));
    row.setObjectId(colObjectIdIndex, new ObjectId());
    assertFalse(row.isNull(colObjectIdIndex));
    row.setNull(colObjectIdIndex);
    assertTrue(row.isNull(colObjectIdIndex));
}

Example 63 with Decimal128

use of org.bson.types.Decimal128 in project realm-java by realm.

the class JNITableTest method findFirst.

@Test
public void findFirst() {
    final int TEST_SIZE = 10;
    Table t = TestHelper.createTableWithAllColumnTypes(sharedRealm);
    long colKey1 = t.getColumnKey("binary");
    long colKey2 = t.getColumnKey("boolean");
    long colKey3 = t.getColumnKey("date");
    long colKey4 = t.getColumnKey("double");
    long colKey5 = t.getColumnKey("float");
    long colKey6 = t.getColumnKey("long");
    long colKey7 = t.getColumnKey("string");
    long colKey8 = t.getColumnKey("decimal128");
    long colKey9 = t.getColumnKey("object_id");
    sharedRealm.beginTransaction();
    for (int i = 0; i < TEST_SIZE; i++) {
        TestHelper.addRowWithValues(t, new long[] { colKey1, colKey2, colKey3, colKey4, colKey5, colKey6, colKey7, colKey8, colKey9 }, new Object[] { new byte[] { 1, 2, 3 }, true, new Date(i), (double) i, (float) i, i, "string " + i, new Decimal128(i), new ObjectId(TestHelper.generateObjectIdHexString(i)) });
    }
    TestHelper.addRowWithValues(t, new long[] { colKey1, colKey2, colKey3, colKey4, colKey5, colKey6, colKey7, colKey8, colKey9 }, new Object[] { new byte[] { 1, 2, 3 }, true, new Date(TEST_SIZE), (double) TEST_SIZE, (float) TEST_SIZE, TEST_SIZE, "", new Decimal128(TEST_SIZE), new ObjectId(TestHelper.generateObjectIdHexString(TEST_SIZE)) });
    sharedRealm.commitTransaction();
    assertEquals(0, t.findFirstBoolean(colKey2, true));
    for (int i = 0; i < TEST_SIZE; i++) {
        assertEquals(i, t.findFirstDate(colKey3, new Date(i)));
        assertEquals(i, t.findFirstDouble(colKey4, (double) i));
        assertEquals(i, t.findFirstFloat(colKey5, (float) i));
        assertEquals(i, t.findFirstLong(colKey6, i));
        assertEquals(i, t.findFirstDecimal128(colKey8, new Decimal128(i)));
        assertEquals(i, t.findFirstObjectId(colKey9, new ObjectId(TestHelper.generateObjectIdHexString(i))));
    }
    try {
        t.findFirstString(colKey7, null);
        fail();
    } catch (IllegalArgumentException ignored) {
    }
    try {
        t.findFirstDate(colKey3, null);
        fail();
    } catch (IllegalArgumentException ignored) {
    }
}

Example 64 with Decimal128

use of org.bson.types.Decimal128 in project realm-java by realm.

the class JNITableTest method findFirstNonExisting.

@Test
public void findFirstNonExisting() {
    Table t = TestHelper.createTableWithAllColumnTypes(sharedRealm);
    long colKey1 = t.getColumnKey("binary");
    long colKey2 = t.getColumnKey("boolean");
    long colKey3 = t.getColumnKey("date");
    long colKey4 = t.getColumnKey("double");
    long colKey5 = t.getColumnKey("float");
    long colKey6 = t.getColumnKey("long");
    long colKey7 = t.getColumnKey("string");
    long colKey8 = t.getColumnKey("decimal128");
    long colKey9 = t.getColumnKey("object_id");
    sharedRealm.beginTransaction();
    TestHelper.addRowWithValues(t, new long[] { colKey1, colKey2, colKey3, colKey4, colKey5, colKey6, colKey7, colKey8, colKey9 }, new Object[] { new byte[] { 1, 2, 3 }, true, new Date(1384423149761L), 4.5D, 5.7F, 100, "string", new Decimal128(0), new ObjectId(TestHelper.generateObjectIdHexString(0)) });
    sharedRealm.commitTransaction();
    assertEquals(-1, t.findFirstBoolean(colKey2, false));
    assertEquals(-1, t.findFirstDate(colKey3, new Date(138442314986L)));
    assertEquals(-1, t.findFirstDouble(colKey4, 1.0D));
    assertEquals(-1, t.findFirstFloat(colKey5, 1.0F));
    assertEquals(-1, t.findFirstLong(colKey6, 50));
    assertEquals(-1, t.findFirstString(colKey7, "anotherstring"));
    assertEquals(-1, t.findFirstDecimal128(colKey8, new Decimal128(1)));
    assertEquals(-1, t.findFirstObjectId(colKey9, new ObjectId(TestHelper.generateObjectIdHexString(1))));
}

Example 65 with Decimal128

use of org.bson.types.Decimal128 in project realm-java by realm.

the class RealmResultsTests method setValue_specificType_internalNameOnDynamicRealms.

@Test
public void setValue_specificType_internalNameOnDynamicRealms() {
    populateMappedAllJavaTypes(5);
    DynamicRealm dynamicRealm = DynamicRealm.getInstance(realm.getConfiguration());
    dynamicRealm.beginTransaction();
    try {
        RealmResults<DynamicRealmObject> collection = dynamicRealm.where("MappedAllJavaTypes").findAll();
        for (BulkSetMethods type : BulkSetMethods.values()) {
            switch(type) {
                case STRING:
                    collection.setString("field_string", "foo");
                    assertElements(collection, obj -> assertEquals("foo", obj.getString("field_string")));
                    break;
                case BOOLEAN:
                    collection.setBoolean("field_boolean", true);
                    assertElements(collection, obj -> assertTrue(obj.getBoolean("field_boolean")));
                    break;
                case BYTE:
                    collection.setByte("field_byte", (byte) 1);
                    assertElements(collection, obj -> assertEquals((byte) 1, obj.getByte("field_byte")));
                    break;
                case SHORT:
                    collection.setShort("field_short", (short) 2);
                    assertElements(collection, obj -> assertEquals((short) 2, obj.getShort("field_short")));
                    break;
                case INTEGER:
                    collection.setInt("field_int", 3);
                    assertElements(collection, obj -> assertEquals(3, obj.getInt("field_int")));
                    break;
                case LONG:
                    collection.setLong("field_long", 4L);
                    assertElements(collection, obj -> assertEquals(4L, obj.getLong("field_long")));
                    break;
                case FLOAT:
                    collection.setFloat("field_float", 1.23F);
                    assertElements(collection, obj -> assertEquals(1.23F, obj.getFloat("field_float"), 0F));
                    break;
                case DOUBLE:
                    collection.setDouble("field_double", 1.234);
                    assertElements(collection, obj -> assertEquals(1.234, obj.getDouble("field_double"), 0F));
                    break;
                case BINARY:
                    collection.setBlob("field_binary", new byte[] { 1, 2, 3 });
                    assertElements(collection, obj -> assertArrayEquals(new byte[] { 1, 2, 3 }, obj.getBlob("field_binary")));
                    break;
                case DATE:
                    collection.setDate("field_date", new Date(1000));
                    assertElements(collection, obj -> assertEquals(new Date(1000), obj.getDate("field_date")));
                    break;
                case DECIMAL128:
                    collection.setDecimal128("field_decimal128", new Decimal128(1000));
                    assertElements(collection, obj -> assertEquals(new Decimal128(1000), obj.getDecimal128("field_decimal128")));
                    break;
                case OBJECT_ID:
                    {
                        String hex = TestHelper.randomObjectIdHexString();
                        collection.setObjectId("field_object_id", new ObjectId(hex));
                        assertElements(collection, obj -> assertEquals(new ObjectId(hex), obj.getObjectId("field_object_id")));
                        break;
                    }
                case UUID:
                    {
                        String uuid = UUID.randomUUID().toString();
                        collection.setUUID("field_uuid", UUID.fromString(uuid));
                        assertElements(collection, obj -> assertEquals(UUID.fromString(uuid), obj.getUUID("field_uuid")));
                        break;
                    }
                case OBJECT:
                    {
                        DynamicRealmObject childObj = dynamicRealm.createObject("MappedAllJavaTypes", 42);
                        collection.setObject("field_object", childObj);
                        assertElements(collection, obj -> assertEquals(childObj, obj.getObject("field_object")));
                        break;
                    }
                case MODEL_LIST:
                    {
                        DynamicRealmObject childObj = dynamicRealm.createObject("MappedAllJavaTypes", 43);
                        collection.setList("field_list", new RealmList<>(childObj));
                        assertElements(collection, obj -> {
                            RealmList<DynamicRealmObject> list = obj.getList("field_list");
                            assertEquals(1, list.size());
                            assertEquals(childObj, list.first());
                        });
                        break;
                    }
                case STRING_VALUE_LIST:
                    collection.setList("field_string_list", new RealmList<>("Foo"));
                    assertElements(collection, obj -> {
                        RealmList<String> list = obj.getList("field_string_list", String.class);
                        assertEquals(1, list.size());
                        assertEquals("Foo", list.first());
                    });
                    break;
                case BOOLEAN_VALUE_LIST:
                    collection.setList("field_boolean_list", new RealmList<>(true));
                    assertElements(collection, obj -> {
                        RealmList<Boolean> list = obj.getList("field_boolean_list", Boolean.class);
                        assertEquals(1, list.size());
                        assertEquals(true, list.first());
                    });
                    break;
                case BYTE_VALUE_LIST:
                    collection.setList("field_byte_list", new RealmList<>((byte) 1));
                    assertElements(collection, obj -> {
                        RealmList<Byte> list = obj.getList("field_byte_list", Byte.class);
                        assertEquals(1, list.size());
                        assertEquals(Byte.valueOf((byte) 1), list.first());
                    });
                    break;
                case SHORT_VALUE_LIST:
                    collection.setList("field_short_list", new RealmList<>((short) 1));
                    assertElements(collection, obj -> {
                        RealmList<Short> list = obj.getList("field_short_list", Short.class);
                        assertEquals(1, list.size());
                        assertEquals(Short.valueOf((short) 1), list.first());
                    });
                    break;
                case INTEGER_VALUE_LIST:
                    collection.setList("field_integer_list", new RealmList<>(1));
                    assertElements(collection, obj -> {
                        RealmList<Integer> list = obj.getList("field_integer_list", Integer.class);
                        assertEquals(1, list.size());
                        assertEquals(Integer.valueOf(1), list.first());
                    });
                    break;
                case LONG_VALUE_LIST:
                    collection.setList("field_long_list", new RealmList<>(1L));
                    assertElements(collection, obj -> {
                        RealmList<Long> list = obj.getList("field_long_list", Long.class);
                        assertEquals(1, list.size());
                        assertEquals(Long.valueOf((byte) 1), list.first());
                    });
                    break;
                case FLOAT_VALUE_LIST:
                    collection.setList("field_float_list", new RealmList<>(1.1F));
                    assertElements(collection, obj -> {
                        RealmList<Float> list = obj.getList("field_float_list", Float.class);
                        assertEquals(1, list.size());
                        assertEquals(1.1F, list.first(), 0F);
                    });
                    break;
                case DOUBLE_VALUE_LIST:
                    collection.setList("field_double_list", new RealmList<>(1.1D));
                    assertElements(collection, obj -> {
                        RealmList<Double> list = obj.getList("field_double_list", Double.class);
                        assertEquals(1, list.size());
                        assertEquals(1.1D, list.first(), 0F);
                    });
                    break;
                case BINARY_VALUE_LIST:
                    collection.setList("field_binary_list", new RealmList<>(new byte[] { 1, 2, 3 }));
                    assertElements(collection, obj -> {
                        RealmList<byte[]> list = obj.getList("field_binary_list", byte[].class);
                        assertEquals(1, list.size());
                        assertArrayEquals(new byte[] { 1, 2, 3 }, list.first());
                    });
                    break;
                case DATE_VALUE_LIST:
                    collection.setList("field_date_list", new RealmList<>(new Date(1000)));
                    assertElements(collection, obj -> {
                        RealmList<Date> list = obj.getList("field_date_list", Date.class);
                        assertEquals(1, list.size());
                        assertEquals(new Date(1000), list.first());
                    });
                    break;
                case DECIMAL128_VALUE_LIST:
                    collection.setList("field_decimal_list", new RealmList<>(new Decimal128(1000)));
                    assertElements(collection, obj -> {
                        RealmList<Decimal128> list = obj.getList("field_decimal_list", Decimal128.class);
                        assertEquals(1, list.size());
                        assertEquals(new Decimal128(1000), list.first());
                    });
                    break;
                case OBJECT_ID_VALUE_LIST:
                    {
                        String hex = TestHelper.randomObjectIdHexString();
                        collection.setList("field_object_id_list", new RealmList<>(new ObjectId(hex)));
                        assertElements(collection, obj -> {
                            RealmList<ObjectId> list = obj.getList("field_object_id_list", ObjectId.class);
                            assertEquals(1, list.size());
                            assertEquals(new ObjectId(hex), list.first());
                        });
                        break;
                    }
                case UUID_VALUE_LIST:
                    {
                        String uuid = UUID.randomUUID().toString();
                        collection.setList("field_uuid_list", new RealmList<>(UUID.fromString(uuid)));
                        assertElements(collection, obj -> {
                            RealmList<UUID> list = obj.getList("field_uuid_list", UUID.class);
                            assertEquals(1, list.size());
                            assertEquals(UUID.fromString(uuid), list.first());
                        });
                        break;
                    }
                default:
                    fail("Unknown type: " + type);
            }
        }
    } finally {
        dynamicRealm.close();
    }
}