Add Normalize option in PostgreSQLDialectProvider to create tables without quotes

Author: mythz

src/ServiceStack.OrmLite.PostgreSQL.Tests/NormalizeTests.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using ServiceStack.OrmLite.Tests;
+using ServiceStack.OrmLite.Tests.UseCase;
+using ServiceStack.Text;
+using Customer = ServiceStack.OrmLite.Tests.Customer;
+using Order = ServiceStack.OrmLite.Tests.Order;
+
+namespace ServiceStack.OrmLite.PostgreSQL.Tests
+{
+    class NormalizeTests
+        : OrmLiteTestBase
+    {
+        public NormalizeTests() : base(Dialect.PostgreSql) { }
+
+        [Test]
+        public void Can_create_and_populate_tables_without_quotes()
+        {
+            using (var db = OpenDbConnection())
+            {
+                PostgreSqlDialectProvider.Instance.Normalize = true;
+
+                CustomerOrdersUseCase.DropTables(db); //Has conflicting 'Order' table
+                db.DropTable<Order>();
+                db.DropTable<CustomerAddress>();
+                db.DropTable<Customer>();
+
+                db.CreateTable<Customer>();
+                db.CreateTable<CustomerAddress>();
+                db.CreateTable<Order>();
+
+                db.GetLastSql().Print();
+
+                var customer = new Customer
+                {
+                    Name = "Customer 1",
+                    PrimaryAddress = new CustomerAddress
+                    {
+                        AddressLine1 = "1 Humpty Street",
+                        City = "Humpty Doo",
+                        State = "Northern Territory",
+                        Country = "Australia"
+                    },
+                    Orders = new[] {
+                        new Order { LineItem = "Line 1", Qty = 1, Cost = 1.99m },
+                        new Order { LineItem = "Line 2", Qty = 2, Cost = 2.99m },
+                    }.ToList(),
+                };
+
+                db.Save(customer, references: true);
+                db.GetLastSql().Print();
+
+                var dbCustomer = db.SingleById<Customer>(customer.Id);
+                Assert.That(dbCustomer.Name, Is.EqualTo(customer.Name));
+
+                var address = db.Single<CustomerAddress>(x => x.CustomerId == customer.Id && x.Id == customer.PrimaryAddress.Id);
+                Assert.That(address.Country, Is.EqualTo("Australia"));
+
+                var orders = db.Select<Order>(x => x.CustomerId == customer.Id);
+                var totalQty = orders.Sum(x => x.Qty);
+                Assert.That(totalQty, Is.EqualTo(3));
+
+                PostgreSqlDialectProvider.Instance.Normalize = false;
+            }
+        }
+    }
+}

src/ServiceStack.OrmLite.PostgreSQL/PostgreSQLDialectProvider.cs

@@ -62,6 +62,106 @@ public PostgreSqlDialectProvider()
             };
         }
 
+        private bool normalize;
+        public bool Normalize
+        {
+            get => normalize;
+            set
+            {
+                normalize = !value;
+                NamingStrategy = value 
+                    ? new OrmLiteNamingStrategyBase()
+                    : new PostgreSqlNamingStrategy();
+            }            
+        }
+
+        //https://www.postgresql.org/docs/7.3/static/sql-keywords-appendix.html
+        public static HashSet<string> ReservedWords = new HashSet<string>(new[]
+        {
+            "ALL",
+            "ANALYSE",
+            "ANALYZE",
+            "AND",
+            "ANY",
+            "AS",
+            "ASC",
+            "AUTHORIZATION",
+            "BETWEEN",
+            "BINARY",
+            "BOTH",
+            "CASE",
+            "CAST",
+            "CHECK",
+            "COLLATE",
+            "COLUMN",
+            "CONSTRAINT",
+            "CURRENT_DATE",
+            "CURRENT_TIME",
+            "CURRENT_TIMESTAMP",
+            "CURRENT_USER",
+            "DEFAULT",
+            "DEFERRABLE",
+            "DISTINCT",
+            "DO",
+            "ELSE",
+            "END",
+            "EXCEPT",
+            "FOR",
+            "FOREIGN",
+            "FREEZE",
+            "FROM",
+            "FULL",
+            "HAVING",
+            "ILIKE",
+            "IN",
+            "INITIALLY",
+            "INNER",
+            "INTERSECT",
+            "INTO",
+            "IS",
+            "ISNULL",
+            "JOIN",
+            "LEADING",
+            "LEFT",
+            "LIKE",
+            "LIMIT",
+            "LOCALTIME",
+            "LOCALTIMESTAMP",
+            "NEW",
+            "NOT",
+            "NOTNULL",
+            "NULL",
+            "OFF",
+            "OFFSET",
+            "OLD",
+            "ON",
+            "ONLY",
+            "OR",
+            "ORDER",
+            "OUTER",
+            "OVERLAPS",
+            "PLACING",
+            "PRIMARY",
+            "REFERENCES",
+            "RIGHT",
+            "SELECT",
+            "SESSION_USER",
+            "SIMILAR",
+            "SOME",
+            "TABLE",
+            "THEN",
+            "TO",
+            "TRAILING",
+            "TRUE",
+            "UNION",
+            "UNIQUE",
+            "USER",
+            "USING",
+            "VERBOSE",
+            "WHEN",
+            "WHERE",
+        }, StringComparer.OrdinalIgnoreCase);
+
         public override string GetColumnDefinition(FieldDefinition fieldDef)
         {
             if (fieldDef.IsRowVersion)
@@ -160,8 +260,9 @@ public override IDbDataParameter CreateParam()
 
         public override bool DoesTableExist(IDbCommand dbCmd, string tableName, string schema = null)
         {
-            var sql = "SELECT COUNT(*) FROM pg_class WHERE relname = {0}"
-                .SqlFmt(tableName);
+            var sql = !Normalize 
+                ? "SELECT COUNT(*) FROM pg_class WHERE relname = {0}".SqlFmt(tableName)
+                : "SELECT COUNT(*) FROM pg_class WHERE lower(relname) = {0}".SqlFmt(tableName.ToLower());
 
             var conn = dbCmd.Connection;
             if (conn != null)
@@ -172,8 +273,9 @@ public override bool DoesTableExist(IDbCommand dbCmd, string tableName, string s
 
                 // If a search path (schema) is specified, and there is only one, then assume the CREATE TABLE directive should apply to that schema.
                 if (!string.IsNullOrEmpty(schema) && !schema.Contains(","))
-                    sql = "SELECT COUNT(*) FROM pg_class JOIN pg_catalog.pg_namespace n ON n.oid = pg_class.relnamespace WHERE relname = {0} AND nspname = {1}"
-                          .SqlFmt(tableName, schema);
+                    sql = !Normalize
+                        ? "SELECT COUNT(*) FROM pg_class JOIN pg_catalog.pg_namespace n ON n.oid = pg_class.relnamespace WHERE relname = {0} AND nspname = {1}".SqlFmt(tableName, schema)
+                        : "SELECT COUNT(*) FROM pg_class JOIN pg_catalog.pg_namespace n ON n.oid = pg_class.relnamespace WHERE lower(relname) = {0} AND lower(nspname) = {1}".SqlFmt(tableName.ToLower(), schema.ToLower());
             }
 
             var result = dbCmd.ExecLongScalar(sql);
@@ -183,11 +285,19 @@ public override bool DoesTableExist(IDbCommand dbCmd, string tableName, string s
 
         public override bool DoesColumnExist(IDbConnection db, string columnName, string tableName, string schema = null)
         {
-            var sql = "SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @tableName AND COLUMN_NAME = @columnName"
-                .SqlFmt(tableName, columnName);
+            var sql = !Normalize
+                ? "SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @tableName AND COLUMN_NAME = @columnName".SqlFmt(tableName, columnName)
+                : "SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE lower(TABLE_NAME) = @tableName AND lower(COLUMN_NAME) = @columnName".SqlFmt(tableName.ToLower(), columnName.ToLower());
 
             if (schema != null)
-                sql += " AND TABLE_SCHEMA = @schema";
+            {
+                sql += !Normalize
+                    ? " AND TABLE_SCHEMA = @schema"
+                    : " AND lower(TABLE_SCHEMA) = @schema";
+
+                if (!Normalize)
+                    schema = schema.ToLower();
+            }
 
             var result = db.SqlScalar<long>(sql, new { tableName, columnName, schema });
 
@@ -217,14 +327,31 @@ public override string ToExecuteProcedureStatement(object objWithProperties)
             return sql;
         }
 
+        public override string GetQuotedTableName(string tableName, string schema = null)
+        {
+            return !Normalize || ReservedWords.Contains(tableName) || (schema != null && ReservedWords.Contains(schema))
+                ? base.GetQuotedTableName(tableName, schema)
+                : schema != null
+                    ? schema + "." + tableName
+                    : tableName;
+        }
+
+        public override string GetQuotedName(string name)
+        {
+            return !Normalize || ReservedWords.Contains(name)
+                ? base.GetQuotedName(name)
+                : name;
+        }
+
         public override string GetQuotedTableName(ModelDefinition modelDef)
         {
             if (!modelDef.IsInSchema)
-            {
                 return base.GetQuotedTableName(modelDef);
-            }
+            if (!Normalize && !ReservedWords.Contains(modelDef.ModelName) && !ReservedWords.Contains(modelDef.Schema))
+                return modelDef.Schema + "." + base.NamingStrategy.GetTableName(modelDef.ModelName);
+
             string escapedSchema = modelDef.Schema.Replace(".", "\".\"");
-            return string.Format("\"{0}\".\"{1}\"", escapedSchema, base.NamingStrategy.GetTableName(modelDef.ModelName));
+            return $"\"{escapedSchema}\".\"{base.NamingStrategy.GetTableName(modelDef.ModelName)}\"";
         }
 
         public override string GetLastInsertIdSqlSuffix<T>()
@@ -236,7 +363,9 @@ public override string GetLastInsertIdSqlSuffix<T>()
             {
                 var modelDef = GetModel(typeof(T));
                 var pkName = NamingStrategy.GetColumnName(modelDef.PrimaryKey.FieldName);
-                return $" RETURNING \"{pkName}\"";
+                return !Normalize
+                    ? $" RETURNING \"{pkName}\""
+                    : " RETURNING " + pkName;
             }
 
             return "; " + SelectIdentitySql;

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

@@ -14,7 +14,7 @@ class Team
             public int? TeamLeaderId { get; set; }
         }
 
-        class TeamUser
+        class Teamuser
         {
             public int Id { get; set; }
 
@@ -28,7 +28,7 @@ public void Can_create_query_with_int_JoinAlias()
         {
             using (var db = OpenDbConnection())
             {
-                db.DropAndCreateTable<TeamUser>();
+                db.DropAndCreateTable<Teamuser>();
                 db.DropAndCreateTable<Team>();
 
                 db.InsertAll(new[] {
@@ -41,13 +41,13 @@ public void Can_create_query_with_int_JoinAlias()
 
                 db.InsertAll(new[]
                 {
-                    new TeamUser
+                    new Teamuser
                     {
                         Id = 1,
                         Name = "User 1",
                         TeamId = 1
                     },
-                    new TeamUser
+                    new Teamuser
                     {
                         Id = 2,
                         Name = "User 2",
@@ -60,13 +60,13 @@ public void Can_create_query_with_int_JoinAlias()
                     where: x => x.Id == 1);
 
                 var q = db.From<Team>();
-                q.Join<TeamUser>((t, u) => t.Id == u.TeamId, db.JoinAlias("TeamUser"));
-                q.Join<TeamUser>((t, u) => t.TeamLeaderId == u.Id, db.JoinAlias("Leader"));
-                q.Where<Team, TeamUser>((t, u) => t.Id == Sql.JoinAlias(u.TeamId, "Leader"));
-                q.Where<TeamUser>(u => Sql.JoinAlias(u.Id, "Leader") == 1);
-                q.Where<Team, TeamUser>((t, u) => Sql.JoinAlias(t.Id, q.DialectProvider.GetQuotedTableName(ModelDefinition<Team>.Definition)) == Sql.JoinAlias(u.TeamId, "Leader")); // Workaround, but only works for fields, not constants
-                q.Where<Team, TeamUser>((user, leader) => Sql.JoinAlias(user.Id, "TeamUser") < Sql.JoinAlias(leader.Id, "Leader"));
-                q.Select<Team, TeamUser, TeamUser>((t, u, l) => new
+                q.Join<Teamuser>((t, u) => t.Id == u.TeamId, db.JoinAlias("Teamuser"));
+                q.Join<Teamuser>((t, u) => t.TeamLeaderId == u.Id, db.JoinAlias("Leader"));
+                q.Where<Team, Teamuser>((t, u) => t.Id == Sql.JoinAlias(u.TeamId, "Leader"));
+                q.Where<Teamuser>(u => Sql.JoinAlias(u.Id, "Leader") == 1);
+                q.Where<Team, Teamuser>((t, u) => Sql.JoinAlias(t.Id, q.DialectProvider.GetQuotedTableName(ModelDefinition<Team>.Definition)) == Sql.JoinAlias(u.TeamId, "Leader")); // Workaround, but only works for fields, not constants
+                q.Where<Team, Teamuser>((user, leader) => Sql.JoinAlias(user.Id, "Teamuser") < Sql.JoinAlias(leader.Id, "Leader"));
+                q.Select<Team, Teamuser, Teamuser>((t, u, l) => new
                 {
                     TeamName = Sql.As(t.Name, "TeamName"),
                     UserName = Sql.As(u.Name, "UserName"),