public void Roundtrip()
        {
            AssertExtensions.WithCulture("de-DE", () =>
            {
                _storage.EnterFluidMode();
                var checker = new RoundtripChecker(_db, _storage);

                // supported ranks
                checker.Check(null, null);
                checker.Check((sbyte)123, (sbyte)123);
                checker.Check(1000, 1000);
                checker.Check(0x80000000L, 0x80000000L);
                checker.Check(3.14, 3.14);
                checker.Check("hello", "hello");
                checker.Check(SharedChecks.SAMPLE_DATETIME, SharedChecks.SAMPLE_DATETIME);
                checker.Check(SharedChecks.SAMPLE_BLOB, SharedChecks.SAMPLE_BLOB);

                // extremal vaues
                SharedChecks.CheckRoundtripOfExtremalValues(checker, checkDateTime: true);

                // conversion to string
                SharedChecks.CheckBigNumberRoundtripForcesString(checker);
                checker.Check(SharedChecks.SAMPLE_GUID, SharedChecks.SAMPLE_GUID.ToString());

                // bool
                checker.Check(true, (sbyte)1);
                checker.Check(false, (sbyte)0);

                // enum
                checker.Check(DayOfWeek.Thursday, (sbyte)4);
            });
        }
Exemple #2
0
        public void StoreToGoodTable()
        {
            _db.Exec("create table kind1 (id integer primary key, p1, p2)");

            var id = _storage.Store("kind1", SharedChecks.MakeRow(
                                        "p1", 123,
                                        "p2", "hello"
                                        ));

            var row = _db.Row(true, "select * from kind1");

            Assert.Equal(123L, row["p1"]);
            Assert.Equal("hello", row["p2"]);
            Assert.Equal(id, row["id"]);

            Assert.Equal(id, _storage.Store("kind1", SharedChecks.MakeRow(
                                                "id", id,
                                                "p1", -1,
                                                "p2", "see you"
                                                )));

            row = _db.Row(true, "select * from kind1");
            Assert.Equal(-1L, row["p1"]);
            Assert.Equal("see you", row["p2"]);
        }
Exemple #3
0
        public void Roundtrip()
        {
            AssertExtensions.WithCulture("de-DE", () =>
            {
                _storage.EnterFluidMode();
                var checker = new RoundtripChecker(_db, _storage);

                // supported ranks
                checker.Check(null, null);
                checker.Check(true, true);
                checker.Check(1000, 1000);
                checker.Check(0x80000000L, 0x80000000L);
                checker.Check(3.14, 3.14);
                checker.Check(7.90M, 7.90M);
                checker.Check("hello", "hello");
                checker.Check(SharedChecks.SAMPLE_DATETIME, SharedChecks.SAMPLE_DATETIME);
                checker.Check(SharedChecks.SAMPLE_GUID, SharedChecks.SAMPLE_GUID);
                checker.Check(SharedChecks.SAMPLE_BLOB, SharedChecks.SAMPLE_BLOB);

                // https://github.com/npgsql/npgsql/issues/11
                checker.Check(
                    SharedChecks.SAMPLE_DATETIME_OFFSET,
                    SharedChecks.SAMPLE_DATETIME_OFFSET.ToLocalTime().DateTime
                    );

                // extremal vaues
                SharedChecks.CheckRoundtripOfExtremalValues(checker, checkDecimal: true, checkDateTime: true);
                checker.Check(UInt64.MaxValue, (decimal)UInt64.MaxValue);

                // enum
                checker.Check(DayOfWeek.Thursday, (int)4);
            });
        }
Exemple #4
0
        public void Booleans()
        {
            _storage.EnterFluidMode();

            var trueKeys = new[]
            {
                _storage.Store("foo", SharedChecks.MakeRow("x", true)),
                _storage.Store("foo", SharedChecks.MakeRow("x", 1)),
                _storage.Store("foo", SharedChecks.MakeRow("x", "1"))
            };

            var falseKeys = new[]
            {
                _storage.Store("foo", SharedChecks.MakeRow("x", false)),
                _storage.Store("foo", SharedChecks.MakeRow("x", 0)),
                _storage.Store("foo", SharedChecks.MakeRow("x", "0"))
            };

            var nullKeys = new[]
            {
                _storage.Store("foo", SharedChecks.MakeRow("x", null)),
                _storage.Store("foo", SharedChecks.MakeRow("x", ""))
            };

            AssertExtensions.Equivalent(trueKeys, _db.Col <object>(true, "select id from foo where x"));
            AssertExtensions.Equivalent(falseKeys, _db.Col <object>(true, "select id from foo where not x"));
            AssertExtensions.Equivalent(nullKeys, _db.Col <object>(true, "select id from foo where x is null"));
        }
Exemple #5
0
        public void Roundtrip()
        {
            AssertExtensions.WithCulture("de-DE", () =>
            {
                _storage.EnterFluidMode();
                var checker = new RoundtripChecker(_db, _storage);

                // native SQLite types
                checker.Check(null, null);
                checker.Check("hello", "hello");
                checker.Check(123L, 123L);
                checker.Check(3.14, 3.14);
                checker.Check(SharedChecks.SAMPLE_BLOB, SharedChecks.SAMPLE_BLOB);

                // extremal vaues
                SharedChecks.CheckRoundtripOfExtremalValues(checker);

                // conversion to string
                checker.Check(SharedChecks.SAMPLE_DATETIME, "1984-06-14 11:22:33");
                SharedChecks.CheckBigNumberRoundtripForcesString(checker);

                // Guid
#if SQLITE_MODE_GENUINE
                checker.Check(SharedChecks.SAMPLE_GUID, SharedChecks.SAMPLE_GUID.ToByteArray());
#else
                checker.Check(SharedChecks.SAMPLE_GUID, SharedChecks.SAMPLE_GUID.ToString().ToUpper());
#endif
                // upscale to long
                checker.Check(0, 0L);
                checker.Check(1, 1L);
                checker.Check(true, 1L);
                checker.Check(false, 0L);
                checker.Check(DayOfWeek.Thursday, 4L);
            });
        }
Exemple #6
0
        public void ChangeSchemaOnStore()
        {
            _db.Exec("create table kind1 (id integer primary key)");
            _storage.EnterFluidMode();

            _storage.Store("kind1", SharedChecks.MakeRow("x", 1));

            var schema = _storage.GetSchema();

            Assert.Equal(SQLiteDetails.RANK_ANY, schema["kind1"]["x"]);

            _storage.Store("kind1", SharedChecks.MakeRow(
                               "x", "hello",
                               "y", 3.14,
                               "z", null
                               ));

            schema = _storage.GetSchema();
            Assert.Equal(SQLiteDetails.RANK_ANY, schema["kind1"]["x"]);
            Assert.Equal(SQLiteDetails.RANK_ANY, schema["kind1"]["y"]);
            Assert.DoesNotContain("z", schema["kind1"].Keys);

            var rows = _db.Rows(true, "select * from kind1 order by id");

            Assert.Equal(1L, rows[0]["x"]);
            Assert.Null(rows[0]["y"]);

            Assert.Equal("hello", rows[1]["x"]);
            Assert.Equal(3.14, rows[1]["y"]);
        }
        public void UTF8_mb4()
        {
            const string pile = "\U0001f4a9";

            _storage.EnterFluidMode();
            var id = _storage.Store("foo", SharedChecks.MakeRow("p", pile));

            Assert.Equal(pile, _storage.Load("foo", id)["p"]);
        }
Exemple #8
0
        public void NotIsNewBean()
        {
            _storage.EnterFluidMode();

            var key = _storage.Store("foo", SharedChecks.MakeRow("a", 1));
            var foo = _api.Load("foo", key);

            Assert.False(_storage.IsNew(foo));
        }
Exemple #9
0
        public void InsertUpdateWithoutValues()
        {
            _storage.EnterFluidMode();

            var id = _storage.Store("kind1", SharedChecks.MakeRow());

            Assert.Equal(1, _db.Cell <int>(true, "select count(*) from kind1"));

            Assert.Null(Record.Exception(() => { _storage.Store("kind1", SharedChecks.MakeRow("id", id)); }));
        }
Exemple #10
0
        public void IsNewBean()
        {
            _storage.EnterFluidMode();

            _storage.Store("foo", SharedChecks.MakeRow("a", 1));

            var foo = _api.Dispense("foo");

            foo["a"] = 2;

            Assert.True(_storage.IsNew(foo));
        }
        public void TransactionIsolation()
        {
            Assert.Equal(IsolationLevel.Unspecified, _db.TransactionIsolation);

            using (var otherFixture = new MariaDbConnectionFixture()) {
                var dbName  = _db.Cell <string>(false, "select database()");
                var otherDb = new DatabaseAccess(otherFixture.Connection, null);

                otherDb.Exec("use " + dbName);
                SharedChecks.CheckReadUncommitted(_db, otherDb);
            }
        }
Exemple #12
0
        public void StoreWithKeyMissingFromDb()
        {
            _storage.EnterFluidMode();

            var error = Record.Exception(() =>
            {
                _storage.Store("foo", SharedChecks.MakeRow(
                                   "id", 123,
                                   "a", 1
                                   ));
            });

            Assert.Equal("Row not found", error.Message);
        }
Exemple #13
0
        public void Trash()
        {
            var emptiness = SharedChecks.MakeRow();

            _storage.EnterFluidMode();

            var ids = new[]
            {
                _storage.Store("kind1", emptiness),
                _storage.Store("kind1", emptiness)
            };

            _storage.Trash("kind1", ids[0]);
            Assert.Equal(1, _db.Cell <int>(true, "select count(*) from kind1"));
        }
Exemple #14
0
        public void Roundtrip()
        {
            AssertExtensions.WithCulture("de-DE", () =>
            {
                _storage.EnterFluidMode();
                var checker = new RoundtripChecker(_db, _storage);

                // similar to https://github.com/StackExchange/dapper-dot-net/issues/229
                _db.QueryExecuting += cmd => {
                    foreach (SqlParameter p in cmd.Parameters)
                    {
                        if (Equals(p.Value, DateTime.MinValue))
                        {
                            p.SqlDbType = SqlDbType.DateTime2;
                        }
                    }
                };

                // supported ranks
                checker.Check(null, null);
                checker.Check(255, (byte)255);
                checker.Check(1000, 1000);
                checker.Check(0x80000000L, 0x80000000L);
                checker.Check(3.14, 3.14);
                checker.Check("hello", "hello");
                checker.Check(SharedChecks.SAMPLE_DATETIME, SharedChecks.SAMPLE_DATETIME);
                checker.Check(SharedChecks.SAMPLE_DATETIME_OFFSET, SharedChecks.SAMPLE_DATETIME_OFFSET);
                checker.Check(SharedChecks.SAMPLE_GUID, SharedChecks.SAMPLE_GUID);
                checker.Check(SharedChecks.SAMPLE_BLOB, SharedChecks.SAMPLE_BLOB);

                // extremal vaues
                SharedChecks.CheckRoundtripOfExtremalValues(checker, checkDateTime: true, checkDateTimeOffset: true);

                // conversion to string
                SharedChecks.CheckBigNumberRoundtripForcesString(checker);

                // bool
                checker.Check(true, (byte)1);
                checker.Check(false, (byte)0);

                // enum
                checker.Check(DayOfWeek.Thursday, (byte)4);
            });
        }
        public void CustomRank_ExistingColumn()
        {
            _db.Exec("create table foo(id int, p geometry)");

            _db.QueryExecuting += cmd => {
                foreach (MySqlParameter p in cmd.Parameters)
                {
                    if (p.Value is MySqlGeometry)
                    {
                        p.MySqlDbType = MySqlDbType.Geometry;
                    }
                }
            };

            _storage.Store("foo", SharedChecks.MakeRow("p", new MySqlGeometry(54.2, 37.61667)));

            // http://stackoverflow.com/q/30584522
            var blob = _db.Cell <byte[]>(false, "select p from foo");

            Assert.Equal(54.2, new MySqlGeometry(MySqlDbType.Geometry, blob).XCoordinate);
        }
Exemple #16
0
        public void StoreToMissingTable()
        {
            _storage.EnterFluidMode();
            _storage.Store("kind1", SharedChecks.MakeRow(
                               "p1", 123,
                               "p2", 3.14,
                               "p3", "hello",
                               "p4", null
                               ));

            var row = _db.Row(true, "select * from kind1");

            Assert.Equal(123L, row["p1"]);
            Assert.Equal(3.14, row["p2"]);
            Assert.Equal("hello", row["p3"]);
            Assert.DoesNotContain("p4", row.Keys);

            var table = _storage.GetSchema()["kind1"];

            Assert.Equal(SQLiteDetails.RANK_ANY, table["p1"]);
            Assert.Equal(SQLiteDetails.RANK_ANY, table["p2"]);
            Assert.Equal(SQLiteDetails.RANK_ANY, table["p3"]);
            Assert.DoesNotContain("p4", table.Keys);
        }
Exemple #17
0
 public void ChangeSchemaWhenFrozen()
 {
     Assert.Throws(SQLitePortability.ExceptionType,
                   () => { _storage.Store("unlucky", SharedChecks.MakeRow("a", 1)); });
 }
Exemple #18
0
 public void CustomRank_MissingColumn()
 {
     SharedChecks.CheckCustomRank_MissingColumn(_db, _storage);
 }
Exemple #19
0
 public void CustomRank_ExistingColumn()
 {
     _db.Exec("create table foo(id int, p smallmoney)");
     _storage.Store("foo", SharedChecks.MakeRow("p", new SqlMoney(9.9)));
     Assert.Equal(9.900M, _db.Cell <object>(false, "select p from foo"));
 }
Exemple #20
0
 public void CompoundKey()
 {
     SharedChecks.CheckCompoundKey(_storage, _keys);
 }
Exemple #21
0
 public void StoringNull()
 {
     SharedChecks.CheckStoringNull(_storage);
 }
Exemple #22
0
 public void GuidQuery()
 {
     SharedChecks.CheckGuidQuery(_db, _storage);
 }
Exemple #23
0
 public void DateTimeQueries()
 {
     SharedChecks.CheckDateTimeQueries(_db, _storage);
 }
Exemple #24
0
 public void SchemaReadingKeepsCache()
 {
     SharedChecks.CheckSchemaReadingKeepsCache(_db, _storage);
 }
Exemple #25
0
 public void CustomRank_ExistingColumn()
 {
     _db.Exec("create table foo(id int, p point)");
     _storage.Store("foo", SharedChecks.MakeRow("p", new NpgsqlPoint(54.2, 37.61667)));
     Assert.Equal(54.2, _db.Cell <NpgsqlPoint>(false, "select p from foo").X);
 }
Exemple #26
0
 public void LongToDouble()
 {
     SharedChecks.CheckLongToDouble(_db, _storage);
 }