/// <summary>
/// This class represents a provier class to get right schema reader based on database type.
/// </summary>
public static SchemaReader GetReader(DbServerType dbServerType)
{
SchemaReader schemaReader = null;
switch (dbServerType)
{
case DbServerType.MsSql:
schemaReader = new SqlServerSchemaReader();
break;
case DbServerType.Sqlite:
schemaReader = new SqliteSchemaReader();
break;
case DbServerType.MySql:
schemaReader = new MySqlSchemaReader();
break;
case DbServerType.Postgres:
schemaReader = new PostgreSqlSchemaReader();
break;
}
return(schemaReader);
}
public Tables GetTables(string classPrefix, string classSuffix, string schemaName)
{
_classPrefix = classPrefix;
_classSuffix = classSuffix;
_schemaName = schemaName;
var _factory = DbProviderFactories.GetFactory("System.Data.SqlClient");
Tables result;
using (var conn = _factory.CreateConnection())
{
conn.ConnectionString = _connectionString;
conn.Open();
var reader = new SqlServerSchemaReader();
result = reader.ReadSchema(conn, _factory);
// Remove unrequired tables/views
for (int i = result.Count - 1; i >= 0; i--)
{
if (_schemaName != null && string.Compare(result[i].Schema, _schemaName, true) != 0)
{
result.RemoveAt(i);
continue;
}
//if (!IncludeViews && result[i].IsView)
//{
// result.RemoveAt(i);
// continue;
//}
}
conn.Close();
var rxClean = new Regex("^(Equals|GetHashCode|GetType|ToString|repo|Save|IsNew|Insert|Update|Delete|Exists|SingleOrDefault|Single|First|FirstOrDefault|Fetch|Page|Query)$");
foreach (var t in result)
{
t.ClassName = _classPrefix + t.ClassName + _classSuffix;
foreach (var c in t.Columns)
{
c.PropertyName = rxClean.Replace(c.PropertyName, "_$1");
// Make sure property name doesn't clash with class name
if (c.PropertyName == t.ClassName)
{
c.PropertyName = "_" + c.PropertyName;
}
}
}
return(result);
}
}
private Tables LoadTables(GenerateContext context)
{
var cmd = context.Command;
if (string.IsNullOrWhiteSpace(cmd.ProviderName))
{
WriteLine("");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("// db provider must be provided");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("");
return(new Tables());
}
if (string.IsNullOrWhiteSpace(cmd.ConnectionString))
{
WriteLine("");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("// connection string must be provided.");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("");
return(new Tables());
}
DbProviderFactory _factory;
try
{
_factory = DbProviderFactories.GetFactory(cmd.ProviderName);
}
catch (Exception x)
{
var error = x.Message.Replace("\r\n", "\n").Replace("\n", " ");
WriteLine("");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("// Failed to load provider `{0}` - {1}", cmd.ProviderName, error);
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("");
return(new Tables());
}
try
{
Tables result;
using (var conn = _factory.CreateConnection())
{
conn.ConnectionString = cmd.ConnectionString;
conn.Open();
SchemaReader reader = null;
if (_factory.GetType().Name == "MySqlClientFactory")
{
reader = new MySqlSchemaReader();
context.EscapeSqlIdentifier = sqlIdentifier => $"`{sqlIdentifier}`";
}
else if (_factory.GetType().Name == "SqlCeProviderFactory")
{
reader = new SqlServerCeSchemaReader();
}
else if (_factory.GetType().Name == "NpgsqlFactory")
{
reader = new PostGreSqlSchemaReader();
context.EscapeSqlIdentifier = sqlIdentifier => $"\"{sqlIdentifier}\"";
}
else if (_factory.GetType().Name == "OracleClientFactory")
{
reader = new OracleSchemaReader();
context.EscapeSqlIdentifier = sqlIdentifier => $"\"{sqlIdentifier.ToUpperInvariant()}\"";
}
else
{
reader = new SqlServerSchemaReader();
}
reader.outer = _outer;
result = reader.ReadSchema(conn, _factory);
// Remove unrequired tables/views
for (int i = result.Count - 1; i >= 0; i--)
{
if (cmd.SchemaName != null && string.Compare(result[i].Schema, cmd.SchemaName, true) != 0)
{
result.RemoveAt(i);
continue;
}
if (!cmd.IncludeViews && result[i].IsView)
{
result.RemoveAt(i);
continue;
}
if (Helpers.StartsWithAny(result[i].ClassName, cmd.ExcludePrefix))
{
result.RemoveAt(i);
continue;
}
}
conn.Close();
var rxClean = new Regex("^(Equals|GetHashCode|GetType|ToString|repo|Save|IsNew|Insert|Update|Delete|Exists|SingleOrDefault|Single|First|FirstOrDefault|Fetch|Page|Query)$");
foreach (var t in result)
{
t.ClassName = cmd.ClassPrefix + t.ClassName + cmd.ClassSuffix;
foreach (var c in t.Columns)
{
c.PropertyName = rxClean.Replace(c.PropertyName, "_$1");
// Make sure property name doesn't clash with class name
if (c.PropertyName == t.ClassName)
{
c.PropertyName = "_" + c.PropertyName;
}
}
}
return(result);
}
}
catch (Exception x)
{
var error = x.Message.Replace("\r\n", "\n").Replace("\n", " ");
WriteLine("");
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("// Failed to read database schema - {0}", error);
WriteLine("// -----------------------------------------------------------------------------------------");
WriteLine("");
return(new Tables());
}
}
private List <StoredProcedure> LoadStoredProcs(DbProviderFactory factory)
{
if (factory == null || !Settings.IncludeStoredProcedures)
{
return(new List <StoredProcedure>());
}
try
{
using (var conn = factory.CreateConnection())
{
if (conn == null)
{
return(new List <StoredProcedure>());
}
conn.ConnectionString = Settings.ConnectionString;
conn.Open();
var reader = new SqlServerSchemaReader(conn, factory);
var storedProcs = reader.ReadStoredProcs();
conn.Close();
using (var sqlConnection = new SqlConnection(Settings.ConnectionString))
{
foreach (var proc in storedProcs)
{
reader.ReadStoredProcReturnObject(sqlConnection, proc);
}
}
// Remove stored procs where the return model type contains spaces and cannot be mapped
// Also need to remove any TVF functions with parameters that are non scalar types, such as DataTable
var validStoredProcedures = new List <StoredProcedure>();
foreach (var sp in storedProcs)
{
if (!sp.ReturnModels.Any())
{
validStoredProcedures.Add(sp);
continue;
}
if (sp.ReturnModels.Any(returnColumns => returnColumns.Any(c => c.ColumnName.Contains(" "))))
{
continue;
}
if (sp.IsTVF && sp.Parameters.Any(c => c.PropertyType == "System.Data.DataTable"))
{
continue;
}
validStoredProcedures.Add(sp);
}
return(validStoredProcedures);
}
}
catch (Exception ex)
{
PrintError("Failed to read database schema for stored procedures.", ex);
return(new List <StoredProcedure>());
}
}
private Tables LoadTables(DbProviderFactory factory)
{
if (factory == null || !(Settings.ElementsToGenerate.HasFlag(Elements.Poco) ||
Settings.ElementsToGenerate.HasFlag(Elements.Context) ||
Settings.ElementsToGenerate.HasFlag(Elements.UnitOfWork) ||
Settings.ElementsToGenerate.HasFlag(Elements.PocoConfiguration)))
{
return(new Tables());
}
try
{
using (var conn = factory.CreateConnection())
{
if (conn == null)
{
return(new Tables());
}
conn.ConnectionString = Settings.ConnectionString;
conn.Open();
var reader = new SqlServerSchemaReader(conn, factory);
var tables = reader.ReadSchema();
var fkList = reader.ReadForeignKeys();
reader.IdentifyForeignKeys(fkList, tables);
foreach (var t in tables)
{
if (Settings.UseDataAnnotations || Settings.UseDataAnnotationsWithFluent)
{
t.SetupDataAnnotations();
}
t.Suffix = Settings.TableSuffix;
}
Settings.AddForeignKeys?.Invoke(fkList, tables);
// Work out if there are any foreign key relationship naming clashes
reader.ProcessForeignKeys(fkList, tables, true);
tables.IdentifyMappingTables(fkList, Settings.UseMappingTables);
// Now we know our foreign key relationships and have worked out if there are any name clashes,
// re-map again with intelligently named relationships.
tables.ResetNavigationProperties();
reader.ProcessForeignKeys(fkList, tables, false);
tables.IdentifyMappingTables(fkList, !Settings.UseMappingTables);
conn.Close();
return(tables);
}
}
catch (Exception x)
{
PrintError("Failed to read database schema in LoadTables().", x);
return(new Tables());
}
}
public Tables LoadTables()
{
writer.WriteLine("// This file was automatically generated by the PetaPoco T4 Template");
writer.WriteLine("// Do not make changes directly to this file - edit the template instead");
writer.WriteLine("// ");
writer.WriteLine("// The following connection settings were used to generate this file");
writer.WriteLine("// ");
writer.WriteLine("// Provider: `{0}`", this.providerName);
writer.WriteLine("// Connection String: `{0}`", ZapPassword(this.connectionString));
writer.WriteLine("// Schema: `{0}`", this.SchemaName);
writer.WriteLine("// Include Views: `{0}`", this.includeViews);
writer.WriteLine("");
DbProviderFactory _factory;
try
{
_factory = DbProviderFactories.GetFactory(this.providerName);
}
catch (Exception x)
{
var error = x.Message.Replace("\r\n", "\n").Replace("\n", " ");
warning(string.Format("Failed to load provider `{0}` - {1}", this.providerName, error));
writer.WriteLine("");
writer.WriteLine("// -----------------------------------------------------------------------------------------");
writer.WriteLine("// Failed to load provider `{0}` - {1}", this.providerName, error);
writer.WriteLine("// -----------------------------------------------------------------------------------------");
writer.WriteLine("");
return new Tables();
}
writer.WriteLine("// Factory Name: `{0}`", _factory.GetType().Name);
try
{
using (var conn = _factory.CreateConnection())
{
conn.ConnectionString = this.connectionString;
conn.Open();
SchemaReader reader;
if (_factory.GetType().Name == "MySqlClientFactory")
{
// MySql
reader = new MySqlSchemaReader();
}
else if (_factory.GetType().Name == "SqlCeProviderFactory")
{
// SQL CE
reader = new SqlServerCeSchemaReader();
}
else if (_factory.GetType().Name == "NpgsqlFactory")
{
// PostgreSQL
reader = new PostGreSqlSchemaReader();
}
else if (_factory.GetType().Name == "OracleClientFactory")
{
// Oracle
reader = new OracleSchemaReader();
}
else if (_factory.GetType().Name == "SQLiteFactory")
{
// Sqlite
reader = new SqliteSchemaReader();
}
else
{
// Assume SQL Server
reader = new SqlServerSchemaReader();
}
reader.outer = writer;
Tables result = reader.ReadSchema(conn, _factory);
// Remove unrequired tables/views
for (int i = result.Count - 1; i >= 0; i--)
{
if (this.SchemaName != null && string.Compare(result[i].Schema, this.SchemaName, true) != 0)
{
result.RemoveAt(i);
continue;
}
if (!this.includeViews && result[i].IsView)
{
result.RemoveAt(i);
}
}
conn.Close();
var rxClean = new Regex("^(Equals|GetHashCode|GetType|ToString|repo|Save|IsNew|Insert|Update|Delete|Exists|SingleOrDefault|Single|First|FirstOrDefault|Fetch|Page|Query)$");
foreach (var t in result)
{
t.ClassName = this.classPrefix + t.ClassName + this.classSuffix;
foreach (var c in t.Columns)
{
c.PropertyName = rxClean.Replace(c.PropertyName, "_$1");
// Make sure property name doesn't clash with class name
if (c.PropertyName == t.ClassName)
{
c.PropertyName = "_" + c.PropertyName;
}
}
}
return result;
}
}
catch (Exception x)
{
var error = x.Message.Replace("\r\n", "\n").Replace("\n", " ");
warning(string.Format("Failed to read database schema - {0}", error));
writer.WriteLine("");
writer.WriteLine("// -----------------------------------------------------------------------------------------");
writer.WriteLine("// Failed to read database schema - {0}", error);
writer.WriteLine("// -----------------------------------------------------------------------------------------");
writer.WriteLine("");
return new Tables();
}
}
public Tables GetTables(string classPrefix, string classSuffix, string schemaName)
{
_classPrefix = classPrefix;
_classSuffix = classSuffix;
_schemaName = schemaName;
var _factory = DbProviderFactories.GetFactory("System.Data.SqlClient");
Tables result;
using (var conn=_factory.CreateConnection())
{
conn.ConnectionString = _connectionString;
conn.Open();
var reader= new SqlServerSchemaReader();
result = reader.ReadSchema(conn, _factory);
// Remove unrequired tables/views
for (int i=result.Count-1; i>=0; i--)
{
if (_schemaName != null && string.Compare(result[i].Schema, _schemaName, true) != 0)
{
result.RemoveAt(i);
continue;
}
//if (!IncludeViews && result[i].IsView)
//{
// result.RemoveAt(i);
// continue;
//}
}
conn.Close();
var rxClean = new Regex("^(Equals|GetHashCode|GetType|ToString|repo|Save|IsNew|Insert|Update|Delete|Exists|SingleOrDefault|Single|First|FirstOrDefault|Fetch|Page|Query)$");
foreach (var t in result)
{
t.ClassName = _classPrefix + t.ClassName + _classSuffix;
foreach (var c in t.Columns)
{
c.PropertyName = rxClean.Replace(c.PropertyName, "_$1");
// Make sure property name doesn't clash with class name
if (c.PropertyName == t.ClassName)
c.PropertyName = "_" + c.PropertyName;
}
}
return result;
}
}
