Fixed failed SqlServer tests

Author: mythz

README.md

@@ -926,11 +926,17 @@ Creating tables is a simple 1-liner:
 ```csharp
 	using (IDbConnection db = ":memory:".OpenDbConnection())
 	{
-		const bool overwrite = false;
-		db.CreateTables(overwrite, typeof(Shipper), typeof(ShipperType));
+      db.CreateTable<ShipperType>();
+      db.CreateTable<Shipper>();
 	}
 
 	/* In debug mode the line above prints:
+  DEBUG: CREATE TABLE "ShipperTypes" 
+  (
+    "ShipperTypeID" INTEGER PRIMARY KEY AUTOINCREMENT, 
+    "Name" VARCHAR(40) NOT NULL 
+  );
+  DEBUG: CREATE UNIQUE INDEX uidx_shippertypes_name ON "ShipperTypes" ("Name" ASC);
 	DEBUG: CREATE TABLE "Shippers" 
 	(
 	  "ShipperID" INTEGER PRIMARY KEY AUTOINCREMENT, 
@@ -941,37 +947,30 @@ Creating tables is a simple 1-liner:
 	  CONSTRAINT "FK_Shippers_ShipperTypes" FOREIGN KEY ("ShipperTypeId") REFERENCES "ShipperTypes" ("ShipperID") 
 	);
 	DEBUG: CREATE UNIQUE INDEX uidx_shippers_companyname ON "Shippers" ("CompanyName" ASC);
-	DEBUG: CREATE TABLE "ShipperTypes" 
-	(
-	  "ShipperTypeID" INTEGER PRIMARY KEY AUTOINCREMENT, 
-	  "Name" VARCHAR(40) NOT NULL 
-	);
-	DEBUG: CREATE UNIQUE INDEX uidx_shippertypes_name ON "ShipperTypes" ("Name" ASC);
 	*/
 ```
 
 ### Transaction Support
 As we have direct access to IDbCommand and friends - playing with transactions is easy:
 
 ```csharp
-	int trainsTypeId, planesTypeId;
-	using (IDbTransaction dbTrans = db.OpenTransaction())
-	{
-		db.Insert(new ShipperType { Name = "Trains" });
-		trainsTypeId = (int) db.GetLastInsertId();
+  var trainsType = new ShipperType { Name = "Trains" };
+  var planesType = new ShipperType { Name = "Planes" };
 
-		db.Insert(new ShipperType { Name = "Planes" });
-		planesTypeId = (int) db.GetLastInsertId();
+  //Playing with transactions
+  using (IDbTransaction dbTrans = db.OpenTransaction())
+  {
+      db.Save(trainsType);
+      db.Save(planesType);
 
-		dbTrans.Commit();
-	}
-	using (IDbTransaction dbTrans = db.OpenTransaction(IsolationLevel.ReadCommitted))
-	{
-		db.Insert(new ShipperType { Name = "Automobiles" });
-		Assert.That(db.Select<ShipperType>(), Has.Count(3));
+      dbTrans.Commit();
+  }
 
-		dbTrans.Rollback();
-	}
+  using (IDbTransaction dbTrans = db.OpenTransaction(IsolationLevel.ReadCommitted))
+  {
+      db.Insert(new ShipperType { Name = "Automobiles" });
+      Assert.That(db.Select<ShipperType>(), Has.Count.EqualTo(3));
+  }
 	Assert.That(db.Select<ShipperType>(), Has.Count(2));
 ```
 
@@ -980,53 +979,52 @@ No ORM is complete without the standard crud operations:
 
 ```csharp
 	//Performing standard Insert's and Selects
-	db.Insert(new Shipper { CompanyName = "Trains R Us", Phone = "555-TRAINS", ShipperTypeId = trainsTypeId });
-	db.Insert(new Shipper { CompanyName = "Planes R Us", Phone = "555-PLANES", ShipperTypeId = planesTypeId });
-	db.Insert(new Shipper { CompanyName = "We do everything!", Phone = "555-UNICORNS", ShipperTypeId = planesTypeId });
-
-	var trainsAreUs = db.First<Shipper>("ShipperTypeId = {0}", trainsTypeId);
-	Assert.That(trainsAreUs.CompanyName, Is.EqualTo("Trains R Us"));
-	Assert.That(db.Select<Shipper>("CompanyName = {0} OR Phone = {1}", "Trains R Us", "555-UNICORNS"), Has.Count(2));
-	Assert.That(db.Select<Shipper>("ShipperTypeId = {0}", planesTypeId), Has.Count(2));
-
-	//Lets update a record
-	trainsAreUs.Phone = "666-TRAINS";
-	db.Update(trainsAreUs);
-	Assert.That(db.SingleById<Shipper>(trainsAreUs.Id).Phone, Is.EqualTo("666-TRAINS"));
-
-	//Then make it disappear
-	db.Delete(trainsAreUs);
-	Assert.That(db.SingleById<Shipper>(trainsAreUs.Id), Is.Null);
-
-	//And bring it back again
-	db.Insert(trainsAreUs);
+  db.Insert(new Shipper { CompanyName = "Trains R Us", Phone = "555-TRAINS", ShipperTypeId = trainsType.Id });
+  db.Insert(new Shipper { CompanyName = "Planes R Us", Phone = "555-PLANES", ShipperTypeId = planesType.Id });
+  db.Insert(new Shipper { CompanyName = "We do everything!", Phone = "555-UNICORNS", ShipperTypeId = planesType.Id });
+
+  var trainsAreUs = db.SingleFmt<Shipper>("ShipperTypeId = {0}", trainsType.Id);
+  Assert.That(trainsAreUs.CompanyName, Is.EqualTo("Trains R Us"));
+  Assert.That(db.SelectFmt<Shipper>("CompanyName = {0} OR Phone = {1}", "Trains R Us", "555-UNICORNS"), Has.Count.EqualTo(2));
+  Assert.That(db.SelectFmt<Shipper>("ShipperTypeId = {0}", planesType.Id), Has.Count.EqualTo(2));
+
+  //Lets update a record
+  trainsAreUs.Phone = "666-TRAINS";
+  db.Update(trainsAreUs);
+          Assert.That(db.SingleById<Shipper>(trainsAreUs.Id).Phone, Is.EqualTo("666-TRAINS"));
+  
+  //Then make it dissappear
+  db.Delete(trainsAreUs);
+          Assert.That(db.SingleById<Shipper>(trainsAreUs.Id), Is.Null);
+
+  //And bring it back again
+  db.Insert(trainsAreUs);
 ```
 
 ### Performing custom queries 
 And with access to raw sql when you need it - the database is your oyster :)
 
 ```csharp
-	//Select only a subset from the table
-	var partialColumns = db.Select<SubsetOfShipper>(typeof (Shipper), "ShipperTypeId = {0}", planesTypeId);
-	Assert.That(partialColumns, Has.Count(2));
+    var partialColumns = db.SelectFmt<SubsetOfShipper>(typeof (Shipper), "ShipperTypeId = {0}", planesType.Id);
+    Assert.That(partialColumns, Has.Count.EqualTo(2));
 
-	//Select into another POCO class that matches the sql results
-	var rows = db.Select<ShipperTypeCount>(
-		"SELECT ShipperTypeId, COUNT(*) AS Total FROM Shippers GROUP BY ShipperTypeId ORDER BY COUNT(*)");
+    //Select into another POCO class that matches sql
+    var rows = db.SelectFmt<ShipperTypeCount>(
+      "SELECT ShipperTypeId, COUNT(*) AS Total FROM Shippers GROUP BY ShipperTypeId ORDER BY COUNT(*)");
 
-	Assert.That(rows, Has.Count(2));
-	Assert.That(rows[0].ShipperTypeId, Is.EqualTo(trainsTypeId));
-	Assert.That(rows[0].Total, Is.EqualTo(1));
-	Assert.That(rows[1].ShipperTypeId, Is.EqualTo(planesTypeId));
-	Assert.That(rows[1].Total, Is.EqualTo(2));
+    Assert.That(rows, Has.Count.EqualTo(2));
+    Assert.That(rows[0].ShipperTypeId, Is.EqualTo(trainsType.Id));
+    Assert.That(rows[0].Total, Is.EqualTo(1));
+    Assert.That(rows[1].ShipperTypeId, Is.EqualTo(planesType.Id));
+    Assert.That(rows[1].Total, Is.EqualTo(2));
 
 
-	//And finally lets quickly clean up the mess we've made:
-	db.DeleteAll<Shipper>();
-	db.DeleteAll<ShipperType>();
+    //And finally lets quickly clean up the mess we've made:
+    db.DeleteAll<Shipper>();
+    db.DeleteAll<ShipperType>();
 
-	Assert.That(db.Select<Shipper>(), Has.Count(0));
-	Assert.That(db.Select<ShipperType>(), Has.Count(0));
+    Assert.That(db.Select<Shipper>(), Has.Count.EqualTo(0));
+    Assert.That(db.Select<ShipperType>(), Has.Count.EqualTo(0));
 ```
 
 ## Other notable Micro ORMs for .NET

src/ServiceStack.OrmLite.Sqlite/SqliteOrmLiteDialectProviderBase.cs

@@ -137,20 +137,6 @@ public override void SetParameter(FieldDefinition fieldDef, IDbDataParameter p)
 
         public override void SetDbValue(FieldDefinition fieldDef, IDataReader dataReader, int colIndex, object instance)
         {
-            if (fieldDef == null || fieldDef.SetValueFn == null || colIndex == NotFound) return;
-            if (dataReader.IsDBNull(colIndex))
-            {
-                if (fieldDef.IsNullable)
-                {
-                    fieldDef.SetValueFn(instance, null);
-                }
-                else
-                {
-                    fieldDef.SetValueFn(instance, fieldDef.FieldType.GetDefaultValue());
-                }
-                return;
-            }
-
             var fieldType = Nullable.GetUnderlyingType(fieldDef.FieldType) ?? fieldDef.FieldType;
             if (fieldType == typeof(Guid))
             {

src/ServiceStack.OrmLite/OrmLiteDialectProviderBase.cs

@@ -282,7 +282,14 @@ public virtual void SetDbValue(FieldDefinition fieldDef, IDataReader dataReader,
             if (fieldDef == null || fieldDef.SetValueFn == null || colIndex == NotFound) return;
             if (dataReader.IsDBNull(colIndex))
             {
-                fieldDef.SetValueFn(instance, null);
+                if (fieldDef.IsNullable)
+                {
+                    fieldDef.SetValueFn(instance, null);
+                }
+                else
+                {
+                    fieldDef.SetValueFn(instance, fieldDef.FieldType.GetDefaultValue());
+                }
                 return;
             }
 

src/ServiceStack.OrmLite/OrmLiteReadExtensions.cs

@@ -99,7 +99,7 @@ public static GetValueDelegate GetValueFn<T>(IDataRecord reader)
                                 case TypeCode.Int32:
                                     return Convert.ToInt32(value);
                                 case TypeCode.Int64:
-                                    return Convert.ToInt16(value);
+                                    return Convert.ToInt64(value);
                                 case TypeCode.Single:
                                     return Convert.ToSingle(value);
                                 case TypeCode.Double:

tests/ServiceStack.OrmLite.Tests/CustomSqlTests.cs

@@ -9,10 +9,10 @@ public class PocoTable
     {
         public int Id { get; set; }
 
-        [CustomField("CHAR(20) null")]
+        [CustomField("CHAR(20)")]
         public string CharColumn { get; set; }
 
-        [CustomField("DECIMAL(18,4) null")]
+        [CustomField("DECIMAL(18,4)")]
         public decimal? DecimalColumn { get; set; }
     }
 
@@ -72,7 +72,7 @@ public void Can_create_field_with_custom_sql()
             {
                 db.DropAndCreateTable<PocoTable>();
 
-                var createTableSql = db.GetLastSql();
+                var createTableSql = db.GetLastSql().Replace("NULL","null");
                 createTableSql.Print();
 
                 Assert.That(createTableSql, Is.StringContaining("\"CharColumn\" CHAR(20) null")

tests/ServiceStack.OrmLite.Tests/Issues/MismatchSchemaTests.cs

@@ -32,7 +32,7 @@ public void Does_allow_reading_from_table_with_mismatched_nullable_int_type()
         {
             using (var db = OpenDbConnection())
             {
-                db.CreateTable<Nullable.ModelIntValue>();
+                db.DropAndCreateTable<Nullable.ModelIntValue>();
 
                 db.Insert(new Nullable.ModelIntValue { Id = 1, Value = null, Text = "Foo" });
 

tests/ServiceStack.OrmLite.Tests/OrmLiteComplexTypesTests.cs

@@ -78,11 +78,11 @@ public void Lists_Of_Guids_Are_Formatted_Correctly()
 
                 db.Insert(item);
 
-                var savedGuidOne = db.Select<string>("SELECT GuidOne FROM WithAListOfGuids").First();
-                Assert.That(savedGuidOne, Is.EqualTo("32cb0acb-db43-4061-a6aa-7f4902a7002a"));
+                var savedGuidOne = db.Select<Guid>("SELECT GuidOne FROM WithAListOfGuids").First();
+                Assert.That(savedGuidOne, Is.EqualTo(new Guid("32cb0acb-db43-4061-a6aa-7f4902a7002a")));
 
-                var savedGuidTwo = db.Select<string>("SELECT GuidTwo FROM WithAListOfGuids").First();
-                Assert.That(savedGuidTwo, Is.EqualTo("13083231-b005-4ff4-ab62-41bdc7f50a4d"));
+                var savedGuidTwo = db.Select<Guid>("SELECT GuidTwo FROM WithAListOfGuids").First();
+                Assert.That(savedGuidTwo, Is.EqualTo(new Guid("13083231-b005-4ff4-ab62-41bdc7f50a4d")));
 
                 var savedGuidList = db.Select<string>("SELECT TheGuids FROM WithAListOfGuids").First();
                 Assert.That(savedGuidList, Is.EqualTo("[18176030-7a1c-4288-82df-a52f71832381,017f986b-f7be-4b6f-b978-ff05fba3b0aa]"));

tests/ServiceStack.OrmLite.Tests/OrmLiteFiltersTests.cs

@@ -13,6 +13,11 @@ public interface IAudit
 
     public class AuditTableA : IAudit
     {
+        public AuditTableA()
+        {
+            this.CreatedDate = this.ModifiedDate = DateTime.UtcNow;
+        }
+
         [AutoIncrement]
         public int Id { get; set; }
         public DateTime CreatedDate { get; set; }

tests/ServiceStack.OrmLite.Tests/ShippersExample.cs

@@ -61,42 +61,42 @@ public void Shippers_UseCase()
 		{
             using (IDbConnection db = OpenDbConnection())
 			{
-                db.DropTables(typeof(Shipper), typeof(ShipperType));
-				const bool overwrite = false;
-                db.CreateTables(overwrite, typeof(ShipperType), typeof(Shipper));
+                db.DropTable<Shipper>();
+                db.DropTable<ShipperType>();
 
-				int trainsTypeId, planesTypeId;
+                db.CreateTable<ShipperType>();
+                db.CreateTable<Shipper>();
+
+                var trainsType = new ShipperType { Name = "Trains" };
+                var planesType = new ShipperType { Name = "Planes" };
 
 				//Playing with transactions
 				using (IDbTransaction dbTrans = db.OpenTransaction())
 				{
-					db.Insert(new ShipperType { Name = "Trains" });
-					trainsTypeId = (int)db.LastInsertId();
-
-					db.Insert(new ShipperType { Name = "Planes" });
-					planesTypeId = (int)db.LastInsertId();
+                    db.Save(trainsType);
+                    db.Save(planesType);
 
 					dbTrans.Commit();
 				}
+
 				using (IDbTransaction dbTrans = db.OpenTransaction(IsolationLevel.ReadCommitted))
 				{
 					db.Insert(new ShipperType { Name = "Automobiles" });
 					Assert.That(db.Select<ShipperType>(), Has.Count.EqualTo(3));
 
-					dbTrans.Rollback();
 				}
 				Assert.That(db.Select<ShipperType>(), Has.Count.EqualTo(2));
 
 
 				//Performing standard Insert's and Selects
-				db.Insert(new Shipper { CompanyName = "Trains R Us", Phone = "555-TRAINS", ShipperTypeId = trainsTypeId });
-				db.Insert(new Shipper { CompanyName = "Planes R Us", Phone = "555-PLANES", ShipperTypeId = planesTypeId });
-				db.Insert(new Shipper { CompanyName = "We do everything!", Phone = "555-UNICORNS", ShipperTypeId = planesTypeId });
+				db.Insert(new Shipper { CompanyName = "Trains R Us", Phone = "555-TRAINS", ShipperTypeId = trainsType.Id });
+				db.Insert(new Shipper { CompanyName = "Planes R Us", Phone = "555-PLANES", ShipperTypeId = planesType.Id });
+				db.Insert(new Shipper { CompanyName = "We do everything!", Phone = "555-UNICORNS", ShipperTypeId = planesType.Id });
 
-				var trainsAreUs = db.SingleFmt<Shipper>("ShipperTypeId = {0}", trainsTypeId);
+				var trainsAreUs = db.SingleFmt<Shipper>("ShipperTypeId = {0}", trainsType.Id);
 				Assert.That(trainsAreUs.CompanyName, Is.EqualTo("Trains R Us"));
 				Assert.That(db.SelectFmt<Shipper>("CompanyName = {0} OR Phone = {1}", "Trains R Us", "555-UNICORNS"), Has.Count.EqualTo(2));
-				Assert.That(db.SelectFmt<Shipper>("ShipperTypeId = {0}", planesTypeId), Has.Count.EqualTo(2));
+				Assert.That(db.SelectFmt<Shipper>("ShipperTypeId = {0}", planesType.Id), Has.Count.EqualTo(2));
 
 				//Lets update a record
 				trainsAreUs.Phone = "666-TRAINS";
@@ -113,17 +113,17 @@ public void Shippers_UseCase()
 
 				//Performing custom queries
 				//Select only a subset from the table
-				var partialColumns = db.SelectFmt<SubsetOfShipper>(typeof (Shipper), "ShipperTypeId = {0}", planesTypeId);
+				var partialColumns = db.SelectFmt<SubsetOfShipper>(typeof (Shipper), "ShipperTypeId = {0}", planesType.Id);
 				Assert.That(partialColumns, Has.Count.EqualTo(2));
 
 				//Select into another POCO class that matches sql
 				var rows = db.SelectFmt<ShipperTypeCount>(
 					"SELECT ShipperTypeId, COUNT(*) AS Total FROM Shippers GROUP BY ShipperTypeId ORDER BY COUNT(*)");
 
 				Assert.That(rows, Has.Count.EqualTo(2));
-				Assert.That(rows[0].ShipperTypeId, Is.EqualTo(trainsTypeId));
+				Assert.That(rows[0].ShipperTypeId, Is.EqualTo(trainsType.Id));
 				Assert.That(rows[0].Total, Is.EqualTo(1));
-				Assert.That(rows[1].ShipperTypeId, Is.EqualTo(planesTypeId));
+				Assert.That(rows[1].ShipperTypeId, Is.EqualTo(planesType.Id));
 				Assert.That(rows[1].Total, Is.EqualTo(2));
 
 

tests/ServiceStack.OrmLite.Tests/TypeDescriptorMetadataTests.cs

@@ -65,11 +65,11 @@ public void Can_change_column_definition()
 
             typeof(DynamicCacheEntry)
                 .GetProperty("Data")
-                .AddAttributes(new StringLengthAttribute(64000));
+                .AddAttributes(new StringLengthAttribute(7000));
 
             db.DropAndCreateTable<DynamicCacheEntry>();
 
-            Assert.That(db.GetLastSql(), Is.StringContaining("\"Data\" VARCHAR(64000)"));
+            Assert.That(db.GetLastSql(), Is.StringContaining("\"Data\" VARCHAR(7000)"));
             db.GetLastSql().Print();
         }