Cleanup and renaming PKs to CompositePK

igrali · igrali · commit b7a55714f4a8 · 2015-04-11T15:19:15.000+02:00
diff --git a/src/SQLite.Net/SQLiteConnection.cs b/src/SQLite.Net/SQLiteConnection.cs
@@ -378,12 +378,12 @@ public int CreateTable(Type ty, CreateFlags createFlags = CreateFlags.None)
 
             if (map.HasCompositePK)
             {
-                var PKs = mapColumns.Where(c => c.IsPK).ToList();
+                var compositePK = mapColumns.Where(c => c.IsPK).ToList();
 
                 var decls = mapColumns.Select(p => Orm.SqlDecl(p, StoreDateTimeAsTicks, Serializer, ExtraTypeMappings, map.HasCompositePK));
                 var decl = string.Join(",\n", decls.ToArray());
                 query.Append(decl).Append(",\n");
-                query.Append("primary key (").Append(string.Join(",", PKs.Select(pk => pk.Name))).Append(")");
+                query.Append("primary key (").Append(string.Join(",", compositePK.Select(pk => pk.Name))).Append(")");
                 query.Append(")");
             }
             else
@@ -547,8 +547,6 @@ private void MigrateTable(TableMapping map)
 
             var toBeAdded = new List<TableMapping.Column>();
 
-            var PKscount = map.Columns.Where(c => c.IsPK).Count();
-
             foreach (var p in map.Columns)
             {
                 var found = false;
@@ -825,17 +823,17 @@ public T Get<T>(object pk) where T : class
             var map = GetMapping(typeof (T));
             if (map.HasCompositePK)
             {
-                IDictionary<string, object> PKs = pk as Dictionary<string, object>;
-                if (PKs == null)
+                IDictionary<string, object> compositePK = pk as Dictionary<string, object>;
+                if (compositePK == null)
                 {
                     throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");
                 }
-                var pks = map.PKs;
-                if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)
+                var cpk = map.CompositePK;
+                if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)
                 {
-                    throw new NotSupportedException("Cannot get from " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");
+                    throw new NotSupportedException("Cannot get from " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");
                 }
-                return Query<T>(map.GetByPrimaryKeySql, PKs.Values.ToArray()).First();
+                return Query<T>(map.GetByPrimaryKeySql, compositePK.Values.ToArray()).First();
             }
             else
             {
@@ -878,17 +876,17 @@ public T Find<T>(object pk) where T : class
             var map = GetMapping(typeof(T));
             if (map.HasCompositePK)
             {
-                IDictionary<string, object> PKs = pk as Dictionary<string, object>;
-                if (PKs == null)
+                IDictionary<string, object> compositePK = pk as Dictionary<string, object>;
+                if (compositePK == null)
                 {
                     throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");
                 }
-                var pks = map.PKs;
-                if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)
+                var cpk = map.CompositePK;
+                if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)
                 {
-                    throw new NotSupportedException("Cannot find in " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");
+                    throw new NotSupportedException("Cannot find in " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");
                 }
-                return Query<T>(map.GetByPrimaryKeySql, PKs.Values.ToArray()).FirstOrDefault();
+                return Query<T>(map.GetByPrimaryKeySql, compositePK.Values.ToArray()).FirstOrDefault();
             }
             else
             {
@@ -936,17 +934,17 @@ public object Find(object pk, TableMapping map)
         {
             if (map.HasCompositePK)
             {
-                IDictionary<string, object> PKs = pk as Dictionary<string, object>;
-                if (PKs == null)
+                IDictionary<string, object> compositePK = pk as Dictionary<string, object>;
+                if (compositePK == null)
                 {
                     throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");
                 }
-                var pks = map.PKs;
-                if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)
+                var cpk = map.CompositePK;
+                if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)
                 {
-                    throw new NotSupportedException("Cannot find in " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");
+                    throw new NotSupportedException("Cannot find in " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");
                 }
-                return Query(map, map.GetByPrimaryKeySql, PKs.Values.ToArray()).FirstOrDefault();
+                return Query(map, map.GetByPrimaryKeySql, compositePK.Values.ToArray()).FirstOrDefault();
             }
             else
             {
@@ -1513,7 +1511,7 @@ public int Insert(object obj, string extra, Type objType)
 
             if (map.HasCompositePK)
             {
-                pk = map.PKs.FirstOrDefault(p => p.IsAutoGuid);
+                pk = map.CompositePK.FirstOrDefault(p => p.IsAutoGuid);
             }
             else
             {
@@ -1635,19 +1633,19 @@ public int Update(object obj, Type objType)
 
             if (map.HasCompositePK)
             {
-                var pks = map.PKs;
+                var compositePK = map.CompositePK;
                 var cols = from p in map.Columns
-                           where !pks.Any(pk => pk == p)
+                           where !compositePK.Any(pk => pk == p)
                            select p;
 
                 var pslist = (from c in cols
                               select c.GetValue(obj)).ToList();
 
-                pslist.AddRange(pks.Select(pk => pk.GetValue(obj)));
+                pslist.AddRange(compositePK.Select(pk => pk.GetValue(obj)));
 
                 q = string.Format("update \"{0}\" set {1} where {2}", map.TableName,
                         string.Join(",", (from c in cols
-                                          select "\"" + c.Name + "\" = ? ").ToArray()), string.Join(" and ", pks.Select(pk => "\"" + pk.Name + "\" = ? ")));
+                                          select "\"" + c.Name + "\" = ? ").ToArray()), string.Join(" and ", compositePK.Select(pk => "\"" + pk.Name + "\" = ? ")));
 
                 ps = pslist.ToArray();
             }
@@ -1747,9 +1745,9 @@ public int Delete(object objectToDelete)
 
             if (map.HasCompositePK)
             {
-                var pks = map.PKs;
-                q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", pks.Select(pk => "\"" + pk.Name + "\" = ? ")));
-                ps = (from pk in pks
+                var compositePK = map.CompositePK;
+                q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", compositePK.Select(pk => "\"" + pk.Name + "\" = ? ")));
+                ps = (from pk in compositePK
                       select pk.GetValue(objectToDelete)).ToArray();
             }
             else
@@ -1785,18 +1783,18 @@ public int Delete<T>(object primaryKey)
 
             if (map.HasCompositePK)
             {
-                var pks = map.PKs;
-                IDictionary<string, object> PKs = primaryKey as Dictionary<string, object>;
-                if (PKs == null)
+                var cpk = map.CompositePK;
+                IDictionary<string, object> compositePK = primaryKey as Dictionary<string, object>;
+                if (compositePK == null)
                 {
                     throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");
                 }
-                if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)
+                if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)
                 {
-                    throw new NotSupportedException("Cannot delete " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");
+                    throw new NotSupportedException("Cannot delete " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");
                 }
-                var q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", PKs.Keys.Select(pk => "\"" + pk + "\" = ? ")));
-                var ps = (from pk in PKs.Values
+                var q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", compositePK.Keys.Select(pk => "\"" + pk + "\" = ? ")));
+                var ps = (from pk in compositePK.Values
                           select pk).ToArray();
                 return Execute(q, ps);
             }
diff --git a/src/SQLite.Net/TableMapping.cs b/src/SQLite.Net/TableMapping.cs
@@ -58,9 +58,9 @@ public TableMapping(Type type, IEnumerable<PropertyInfo> properties, CreateFlags
                 }
             }
             Columns = cols.ToArray();
-            PKs = Columns.Where(col => col.IsPK).ToArray();
+            CompositePK = Columns.Where(col => col.IsPK).ToArray();
 
-            if (PKs.Length > 1)
+            if (CompositePK.Length > 1)
             {
                 HasCompositePK = true;
             }
@@ -83,14 +83,14 @@ public TableMapping(Type type, IEnumerable<PropertyInfo> properties, CreateFlags
                 HasAutoIncPK = _autoPk != null;
             }
 
-            if (PKs.Length > 1)
+            if (CompositePK.Length > 1)
             {
-                string pksString = string.Join(" and ", PKs.Select(pk => "\"" + pk.Name + "\" = ? "));
-                GetByPrimaryKeySql = string.Format("select * from \"{0}\" where {1}", TableName, pksString);
+                string compositePKString = string.Join(" and ", CompositePK.Select(pk => "\"" + pk.Name + "\" = ? "));
+                GetByPrimaryKeySql = string.Format("select * from \"{0}\" where {1}", TableName, compositePKString);
             }
-            else if (PKs.Length == 1)
+            else if (PK != null)
             {
-                string pkString = PKs.FirstOrDefault().Name;
+                string pkString = PK.Name;
                 GetByPrimaryKeySql = string.Format("select * from \"{0}\" where \"{1}\" = ?", TableName, pkString);
             }
             else
@@ -116,7 +116,7 @@ public Column PK
             {
                 if (HasCompositePK)
                 {
-                    throw new NotSupportedException("Table has a composite primary key. Use PKs property instead.");
+                    throw new NotSupportedException("Table has a composite primary key. Use CompositePK property instead.");
                 }
                 else
                 {
@@ -126,7 +126,7 @@ public Column PK
         }
 
         [PublicAPI]
-        public Column[] PKs { get; private set; }
+        public Column[] CompositePK { get; private set; }
 
         [PublicAPI]
         public string GetByPrimaryKeySql { get; private set; }
diff --git a/tests/DeleteTest.cs b/tests/DeleteTest.cs
@@ -164,11 +164,11 @@ public void DeletePKNoneComposite()
         {
             var db = CreateDb();
 
-            var pks = new Dictionary<string, object>();
-            pks.Add("Id", 348597);
-            pks.Add("TestIndex", 348598);
+            var compositePK = new Dictionary<string, object>();
+            compositePK.Add("Id", 348597);
+            compositePK.Add("TestIndex", 348598);
 
-            var r = db.Delete<TestTableCompositeKey>(pks);
+            var r = db.Delete<TestTableCompositeKey>(compositePK);
 
             Assert.AreEqual(0, r);
             Assert.AreEqual(Count, db.Table<TestTableCompositeKey>().Count());
@@ -179,11 +179,11 @@ public void DeletePKOneComposite()
         {
             var db = CreateDb();
 
-            var pks = new Dictionary<string, object>();
-            pks.Add("Id", 1);
-            pks.Add("TestIndex", 2);
+            var compositePK = new Dictionary<string, object>();
+            compositePK.Add("Id", 1);
+            compositePK.Add("TestIndex", 2);
 
-            var r = db.Delete<TestTableCompositeKey>(pks);
+            var r = db.Delete<TestTableCompositeKey>(compositePK);
 
             Assert.AreEqual(1, r);
             Assert.AreEqual(Count - 1, db.Table<TestTableCompositeKey>().Count());

Original file line number	Diff line number	Diff line change
`@@ -378,12 +378,12 @@ public int CreateTable(Type ty, CreateFlags createFlags = CreateFlags.None)`
`378`	`378`
`379`	`379`	`if (map.HasCompositePK)`
`380`	`380`	`{`
`381`		`- var PKs = mapColumns.Where(c => c.IsPK).ToList();`
	`381`	`+ var compositePK = mapColumns.Where(c => c.IsPK).ToList();`
`382`	`382`
`383`	`383`	`var decls = mapColumns.Select(p => Orm.SqlDecl(p, StoreDateTimeAsTicks, Serializer, ExtraTypeMappings, map.HasCompositePK));`
`384`	`384`	`var decl = string.Join(",\n", decls.ToArray());`
`385`	`385`	`query.Append(decl).Append(",\n");`
`386`		`- query.Append("primary key (").Append(string.Join(",", PKs.Select(pk => pk.Name))).Append(")");`
	`386`	`+ query.Append("primary key (").Append(string.Join(",", compositePK.Select(pk => pk.Name))).Append(")");`
`387`	`387`	`query.Append(")");`
`388`	`388`	`}`
`389`	`389`	`else`
`@@ -547,8 +547,6 @@ private void MigrateTable(TableMapping map)`
`547`	`547`
`548`	`548`	`var toBeAdded = new List<TableMapping.Column>();`
`549`	`549`
`550`		`- var PKscount = map.Columns.Where(c => c.IsPK).Count();`
`551`		`-`
`552`	`550`	`foreach (var p in map.Columns)`
`553`	`551`	`{`
`554`	`552`	`var found = false;`
`@@ -825,17 +823,17 @@ public T Get<T>(object pk) where T : class`
`825`	`823`	`var map = GetMapping(typeof (T));`
`826`	`824`	`if (map.HasCompositePK)`
`827`	`825`	`{`
`828`		`- IDictionary<string, object> PKs = pk as Dictionary<string, object>;`
`829`		`- if (PKs == null)`
	`826`	`+ IDictionary<string, object> compositePK = pk as Dictionary<string, object>;`
	`827`	`+ if (compositePK == null)`
`830`	`828`	`{`
`831`	`829`	`throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");`
`832`	`830`	`}`
`833`		`- var pks = map.PKs;`
`834`		`- if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)`
	`831`	`+ var cpk = map.CompositePK;`
	`832`	`+ if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)`
`835`	`833`	`{`
`836`		`- throw new NotSupportedException("Cannot get from " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");`
	`834`	`+ throw new NotSupportedException("Cannot get from " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");`
`837`	`835`	`}`
`838`		`- return Query<T>(map.GetByPrimaryKeySql, PKs.Values.ToArray()).First();`
	`836`	`+ return Query<T>(map.GetByPrimaryKeySql, compositePK.Values.ToArray()).First();`
`839`	`837`	`}`
`840`	`838`	`else`
`841`	`839`	`{`
`@@ -878,17 +876,17 @@ public T Find<T>(object pk) where T : class`
`878`	`876`	`var map = GetMapping(typeof(T));`
`879`	`877`	`if (map.HasCompositePK)`
`880`	`878`	`{`
`881`		`- IDictionary<string, object> PKs = pk as Dictionary<string, object>;`
`882`		`- if (PKs == null)`
	`879`	`+ IDictionary<string, object> compositePK = pk as Dictionary<string, object>;`
	`880`	`+ if (compositePK == null)`
`883`	`881`	`{`
`884`	`882`	`throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");`
`885`	`883`	`}`
`886`		`- var pks = map.PKs;`
`887`		`- if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)`
	`884`	`+ var cpk = map.CompositePK;`
	`885`	`+ if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)`
`888`	`886`	`{`
`889`		`- throw new NotSupportedException("Cannot find in " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");`
	`887`	`+ throw new NotSupportedException("Cannot find in " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");`
`890`	`888`	`}`
`891`		`- return Query<T>(map.GetByPrimaryKeySql, PKs.Values.ToArray()).FirstOrDefault();`
	`889`	`+ return Query<T>(map.GetByPrimaryKeySql, compositePK.Values.ToArray()).FirstOrDefault();`
`892`	`890`	`}`
`893`	`891`	`else`
`894`	`892`	`{`
`@@ -936,17 +934,17 @@ public object Find(object pk, TableMapping map)`
`936`	`934`	`{`
`937`	`935`	`if (map.HasCompositePK)`
`938`	`936`	`{`
`939`		`- IDictionary<string, object> PKs = pk as Dictionary<string, object>;`
`940`		`- if (PKs == null)`
	`937`	`+ IDictionary<string, object> compositePK = pk as Dictionary<string, object>;`
	`938`	`+ if (compositePK == null)`
`941`	`939`	`{`
`942`	`940`	`throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");`
`943`	`941`	`}`
`944`		`- var pks = map.PKs;`
`945`		`- if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)`
	`942`	`+ var cpk = map.CompositePK;`
	`943`	`+ if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)`
`946`	`944`	`{`
`947`		`- throw new NotSupportedException("Cannot find in " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");`
	`945`	`+ throw new NotSupportedException("Cannot find in " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");`
`948`	`946`	`}`
`949`		`- return Query(map, map.GetByPrimaryKeySql, PKs.Values.ToArray()).FirstOrDefault();`
	`947`	`+ return Query(map, map.GetByPrimaryKeySql, compositePK.Values.ToArray()).FirstOrDefault();`
`950`	`948`	`}`
`951`	`949`	`else`
`952`	`950`	`{`
`@@ -1513,7 +1511,7 @@ public int Insert(object obj, string extra, Type objType)`
`1513`	`1511`
`1514`	`1512`	`if (map.HasCompositePK)`
`1515`	`1513`	`{`
`1516`		`- pk = map.PKs.FirstOrDefault(p => p.IsAutoGuid);`
	`1514`	`+ pk = map.CompositePK.FirstOrDefault(p => p.IsAutoGuid);`
`1517`	`1515`	`}`
`1518`	`1516`	`else`
`1519`	`1517`	`{`
`@@ -1635,19 +1633,19 @@ public int Update(object obj, Type objType)`
`1635`	`1633`
`1636`	`1634`	`if (map.HasCompositePK)`
`1637`	`1635`	`{`
`1638`		`- var pks = map.PKs;`
	`1636`	`+ var compositePK = map.CompositePK;`
`1639`	`1637`	`var cols = from p in map.Columns`
`1640`		`- where !pks.Any(pk => pk == p)`
	`1638`	`+ where !compositePK.Any(pk => pk == p)`
`1641`	`1639`	`select p;`
`1642`	`1640`
`1643`	`1641`	`var pslist = (from c in cols`
`1644`	`1642`	`select c.GetValue(obj)).ToList();`
`1645`	`1643`
`1646`		`- pslist.AddRange(pks.Select(pk => pk.GetValue(obj)));`
	`1644`	`+ pslist.AddRange(compositePK.Select(pk => pk.GetValue(obj)));`
`1647`	`1645`
`1648`	`1646`	`q = string.Format("update \"{0}\" set {1} where {2}", map.TableName,`
`1649`	`1647`	`string.Join(",", (from c in cols`
`1650`		`- select "\"" + c.Name + "\" = ? ").ToArray()), string.Join(" and ", pks.Select(pk => "\"" + pk.Name + "\" = ? ")));`
	`1648`	`+ select "\"" + c.Name + "\" = ? ").ToArray()), string.Join(" and ", compositePK.Select(pk => "\"" + pk.Name + "\" = ? ")));`
`1651`	`1649`
`1652`	`1650`	`ps = pslist.ToArray();`
`1653`	`1651`	`}`
`@@ -1747,9 +1745,9 @@ public int Delete(object objectToDelete)`
`1747`	`1745`
`1748`	`1746`	`if (map.HasCompositePK)`
`1749`	`1747`	`{`
`1750`		`- var pks = map.PKs;`
`1751`		`- q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", pks.Select(pk => "\"" + pk.Name + "\" = ? ")));`
`1752`		`- ps = (from pk in pks`
	`1748`	`+ var compositePK = map.CompositePK;`
	`1749`	`+ q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", compositePK.Select(pk => "\"" + pk.Name + "\" = ? ")));`
	`1750`	`+ ps = (from pk in compositePK`
`1753`	`1751`	`select pk.GetValue(objectToDelete)).ToArray();`
`1754`	`1752`	`}`
`1755`	`1753`	`else`
`@@ -1785,18 +1783,18 @@ public int Delete<T>(object primaryKey)`
`1785`	`1783`
`1786`	`1784`	`if (map.HasCompositePK)`
`1787`	`1785`	`{`
`1788`		`- var pks = map.PKs;`
`1789`		`- IDictionary<string, object> PKs = primaryKey as Dictionary<string, object>;`
`1790`		`- if (PKs == null)`
	`1786`	`+ var cpk = map.CompositePK;`
	`1787`	`+ IDictionary<string, object> compositePK = primaryKey as Dictionary<string, object>;`
	`1788`	`+ if (compositePK == null)`
`1791`	`1789`	`{`
`1792`	`1790`	`throw new NotSupportedException(map.TableName + " table has a composite primary key. Make sure primary key is passed in as Dictionary<string, object>.");`
`1793`	`1791`	`}`
`1794`		`- if (PKs.Keys.Intersect(pks.Select(p => p.Name)).Count() < pks.Length)`
	`1792`	`+ if (compositePK.Keys.Intersect(cpk.Select(p => p.Name)).Count() < cpk.Length)`
`1795`	`1793`	`{`
`1796`		`- throw new NotSupportedException("Cannot delete " + map.TableName + ": PKs mismatch. Make sure PK names are valid.");`
	`1794`	`+ throw new NotSupportedException("Cannot delete " + map.TableName + ": CompositePK mismatch. Make sure PK names are valid.");`
`1797`	`1795`	`}`
`1798`		`- var q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", PKs.Keys.Select(pk => "\"" + pk + "\" = ? ")));`
`1799`		`- var ps = (from pk in PKs.Values`
	`1796`	`+ var q = string.Format("delete from \"{0}\" where {1}", map.TableName, string.Join(" and ", compositePK.Keys.Select(pk => "\"" + pk + "\" = ? ")));`
	`1797`	`+ var ps = (from pk in compositePK.Values`
`1800`	`1798`	`select pk).ToArray();`
`1801`	`1799`	`return Execute(q, ps);`
`1802`	`1800`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,9 +58,9 @@ public TableMapping(Type type, IEnumerable<PropertyInfo> properties, CreateFlags`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`Columns = cols.ToArray();`
`61`		`- PKs = Columns.Where(col => col.IsPK).ToArray();`
	`61`	`+ CompositePK = Columns.Where(col => col.IsPK).ToArray();`
`62`	`62`
`63`		`- if (PKs.Length > 1)`
	`63`	`+ if (CompositePK.Length > 1)`
`64`	`64`	`{`
`65`	`65`	`HasCompositePK = true;`
`66`	`66`	`}`
`@@ -83,14 +83,14 @@ public TableMapping(Type type, IEnumerable<PropertyInfo> properties, CreateFlags`
`83`	`83`	`HasAutoIncPK = _autoPk != null;`
`84`	`84`	`}`
`85`	`85`
`86`		`- if (PKs.Length > 1)`
	`86`	`+ if (CompositePK.Length > 1)`
`87`	`87`	`{`
`88`		`- string pksString = string.Join(" and ", PKs.Select(pk => "\"" + pk.Name + "\" = ? "));`
`89`		`- GetByPrimaryKeySql = string.Format("select * from \"{0}\" where {1}", TableName, pksString);`
	`88`	`+ string compositePKString = string.Join(" and ", CompositePK.Select(pk => "\"" + pk.Name + "\" = ? "));`
	`89`	`+ GetByPrimaryKeySql = string.Format("select * from \"{0}\" where {1}", TableName, compositePKString);`
`90`	`90`	`}`
`91`		`- else if (PKs.Length == 1)`
	`91`	`+ else if (PK != null)`
`92`	`92`	`{`
`93`		`- string pkString = PKs.FirstOrDefault().Name;`
	`93`	`+ string pkString = PK.Name;`
`94`	`94`	`GetByPrimaryKeySql = string.Format("select * from \"{0}\" where \"{1}\" = ?", TableName, pkString);`
`95`	`95`	`}`
`96`	`96`	`else`
`@@ -116,7 +116,7 @@ public Column PK`
`116`	`116`	`{`
`117`	`117`	`if (HasCompositePK)`
`118`	`118`	`{`
`119`		`- throw new NotSupportedException("Table has a composite primary key. Use PKs property instead.");`
	`119`	`+ throw new NotSupportedException("Table has a composite primary key. Use CompositePK property instead.");`
`120`	`120`	`}`
`121`	`121`	`else`
`122`	`122`	`{`
`@@ -126,7 +126,7 @@ public Column PK`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`[PublicAPI]`
`129`		`- public Column[] PKs { get; private set; }`
	`129`	`+ public Column[] CompositePK { get; private set; }`
`130`	`130`
`131`	`131`	`[PublicAPI]`
`132`	`132`	`public string GetByPrimaryKeySql { get; private set; }`