public void ReadWrite() { DateTime val = DateTime.UtcNow; DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Local); DateTimeClass basic = new DateTimeClass(); basic.Id = 1; basic.LocalDateTimeValue = val; ISession s = OpenSession(); s.Save(basic); s.Flush(); s.Close(); s = OpenSession(); basic = (DateTimeClass)s.Load(typeof(DateTimeClass), 1); Assert.AreEqual(DateTimeKind.Local, basic.LocalDateTimeValue.Value.Kind); Assert.AreEqual(expected, basic.LocalDateTimeValue.Value); s.Delete(basic); s.Flush(); s.Close(); }
public virtual void SaveUseExpectedSqlType() { var driver = (ClientDriverWithParamsStats)Sfi.ConnectionProvider.Driver; using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var d = new DateTimeClass { Id = 2, Value = Now, NullableValue = Now }; driver.ClearStats(); s.Save(d); t.Commit(); } var expected = 3; // GenericBatchingBatcher uses IDriver.GenerateCommand method to create the batching command, // so the expected result will be doubled as GenerateCommand calls IDriver.GenerateParameter // for each parameter. if (Sfi.Settings.BatcherFactory is GenericBatchingBatcherFactory) { expected *= 2; } // 2 properties + revision AssertSqlType(driver, expected, true); }
public async Task ReadWriteAsync() { DateTime val = DateTime.UtcNow; DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Utc); DateTimeClass basic = new DateTimeClass(); basic.Id = 1; basic.UtcDateTimeValue = val; ISession s = OpenSession(); await(s.SaveAsync(basic)); await(s.FlushAsync()); s.Close(); s = OpenSession(); basic = (DateTimeClass)await(s.LoadAsync(typeof(DateTimeClass), 1)); Assert.AreEqual(DateTimeKind.Utc, basic.UtcDateTimeValue.Value.Kind); Assert.AreEqual(expected, basic.UtcDateTimeValue.Value); await(s.DeleteAsync(basic)); await(s.FlushAsync()); s.Close(); }
public void LowerDigitsAreIgnored() { if (!Dialect.SupportsDateTimeScale) { Assert.Ignore("Lower digits cannot be ignored when dialect does not support scale"); } var baseDate = new DateTime(2017, 10, 01, 17, 55, 24, 548, GetTypeKind()); var entity = new DateTimeClass { Id = AdditionalDateId, Value = baseDate.AddTicks(TimeSpan.TicksPerMillisecond / 3) }; Assert.That(entity.Value, Is.Not.EqualTo(baseDate)); using (var s = OpenSession()) using (var t = s.BeginTransaction()) { s.Save(entity); t.Commit(); } using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var retrieved = s.Load <DateTimeClass>(AdditionalDateId); Assert.That(retrieved.Value, Is.EqualTo(baseDate)); t.Commit(); } }
protected override void OnSetUp() { base.OnSetUp(); using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var d = new DateTimeClass { Id = DateId, Value = Now }; s.Save(d); t.Commit(); } }
private async Task ReadWriteAsync(DateTime expected, CancellationToken cancellationToken = default(CancellationToken)) { // Add an hour to check it is correctly ignored once read back from db. var basic = new DateTimeClass { Id = AdditionalDateId, Value = expected.AddHours(1) }; using (var s = OpenSession()) { await(s.SaveAsync(basic, cancellationToken)); await(s.FlushAsync(cancellationToken)); } using (var s = OpenSession()) { basic = await(s.GetAsync <DateTimeClass>(AdditionalDateId, cancellationToken)); Assert.That(basic.Value, Is.EqualTo(expected)); await(s.DeleteAsync(basic, cancellationToken)); await(s.FlushAsync(cancellationToken)); } }
private void ReadWrite(DateTime expected) { // Add an hour to check it is correctly ignored once read back from db. var basic = new DateTimeClass { Id = AdditionalDateId, Value = expected.AddHours(1) }; using (var s = OpenSession()) { s.Save(basic); s.Flush(); } using (var s = OpenSession()) { basic = s.Get <DateTimeClass>(AdditionalDateId); Assert.That(basic.Value, Is.EqualTo(expected)); s.Delete(basic); s.Flush(); } }
public virtual async Task SaveUseExpectedSqlTypeAsync() { var driver = (ClientDriverWithParamsStats)Sfi.ConnectionProvider.Driver; using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var d = new DateTimeClass { Id = 2, Value = Now, NullableValue = Now }; driver.ClearStats(); await(s.SaveAsync(d)); await(t.CommitAsync()); } // 2 properties + revision AssertSqlType(driver, 3, true); }
public void ReadWrite() { DateTime val = DateTime.UtcNow; DateTime expected = new DateTime(val.Year, val.Month, val.Day, val.Hour, val.Minute, val.Second, DateTimeKind.Utc); DateTimeClass basic = new DateTimeClass(); basic.Id = 1; basic.UtcDateTimeValue = val; ISession s = OpenSession(); s.Save(basic); s.Flush(); s.Close(); s = OpenSession(); basic = (DateTimeClass) s.Load(typeof (DateTimeClass), 1); Assert.AreEqual(DateTimeKind.Utc, basic.UtcDateTimeValue.Value.Kind); Assert.AreEqual(expected, basic.UtcDateTimeValue.Value); s.Delete(basic); s.Flush(); s.Close(); }
public void ReadWrite(DateTimeKind kind) { var entity = new DateTimeClass { Id = AdditionalDateId, Value = GetTestDate(kind) }; var typeKind = GetTypeKind(); // Now must be acquired before transaction because some db freezes current_timestamp at transaction start, // like PostgreSQL. https://www.postgresql.org/docs/7.2/static/functions-datetime.html#AEN6700 // This then wrecks tests with DbTimestampType if the always out of tran Now is called for fetching // beforeNow only after transaction start. // And account db accuracy var beforeNow = Now.AddTicks(-DateAccuracyInTicks); // Save using (var s = OpenSession()) using (var t = s.BeginTransaction()) { s.Save(entity); if (kind != typeKind && typeKind != DateTimeKind.Unspecified) { Assert.That(() => t.Commit(), Throws.TypeOf <PropertyValueException>()); return; } t.Commit(); } var afterNow = Now.AddTicks(DateAccuracyInTicks); if (RevisionCheck) { Assert.That(entity.Revision, Is.GreaterThan(beforeNow).And.LessThan(afterNow), "Revision not correctly seeded."); if (typeKind != DateTimeKind.Unspecified) { Assert.That(entity.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly seeded."); } Assert.That(entity.NullableValue, Is.Null, "NullableValue unexpectedly seeded."); } // Retrieve, compare then update DateTimeClass retrieved; using (var s = OpenSession()) { using (var t = s.BeginTransaction()) { retrieved = s.Get <DateTimeClass>(AdditionalDateId); Assert.That(retrieved, Is.Not.Null, "Entity not saved or cannot be retrieved by its key."); Assert.That(retrieved.Value, Is.EqualTo(GetExpectedValue(entity.Value)), "Unexpected value."); if (RevisionCheck) { Assert.That(retrieved.Revision, Is.EqualTo(entity.Revision), "Revision should be the same."); } Assert.That(retrieved.NullableValue, Is.EqualTo(entity.NullableValue), "NullableValue should be the same."); if (typeKind != DateTimeKind.Unspecified) { Assert.That(retrieved.Value.Kind, Is.EqualTo(typeKind), "Value kind not correctly retrieved."); if (RevisionCheck) { Assert.That(retrieved.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly retrieved."); } } t.Commit(); } beforeNow = Now.AddTicks(-DateAccuracyInTicks); using (var t = s.BeginTransaction()) { retrieved.NullableValue = GetTestDate(kind); retrieved.Value = GetTestDate(kind).AddMonths(-1); t.Commit(); } afterNow = Now.AddTicks(DateAccuracyInTicks); } if (RevisionCheck) { Assert.That( retrieved.Revision, Is.GreaterThan(beforeNow).And.LessThan(afterNow).And.GreaterThanOrEqualTo(entity.Revision), "Revision not correctly incremented."); if (typeKind != DateTimeKind.Unspecified) { Assert.That(retrieved.Revision.Kind, Is.EqualTo(typeKind), "Revision kind incorrectly changed."); } } // Retrieve and compare again using (var s = OpenSession()) using (var t = s.BeginTransaction()) { var retrievedAgain = s.Get <DateTimeClass>(AdditionalDateId); Assert.That(retrievedAgain, Is.Not.Null, "Entity deleted or cannot be retrieved again by its key."); Assert.That( retrievedAgain.Value, Is.EqualTo(GetExpectedValue(retrieved.Value)), "Unexpected value at second compare."); if (RevisionCheck) { Assert.That(retrievedAgain.Revision, Is.EqualTo(retrieved.Revision), "Revision should be the same again."); } Assert.That( retrievedAgain.NullableValue, Is.EqualTo(GetExpectedValue(retrieved.NullableValue.Value)), "Unexpected NullableValue at second compare."); if (typeKind != DateTimeKind.Unspecified) { Assert.That(retrievedAgain.Value.Kind, Is.EqualTo(typeKind), "Value kind not correctly retrieved again."); if (RevisionCheck) { Assert.That(retrievedAgain.Revision.Kind, Is.EqualTo(typeKind), "Revision kind not correctly retrieved again."); } Assert.That( retrievedAgain.NullableValue.Value.Kind, Is.EqualTo(typeKind), "NullableValue kind not correctly retrieved again."); } t.Commit(); } }