protected override void LoadConstraints(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat, Names names)
{
var constraints = ReadConstraints(conn, schemaName.DbName);
//sort tables - parents first (this is moving to SchemaPostprocess)
//TableSorter.Sort(tables, constraints);
foreach (DataConstraint keyColRow in constraints)
{
//find my table:
string fullKeyDbName = GetFullDbName(keyColRow.TableName, keyColRow.TableSchema);
DbLinq.Schema.Dbml.Table table = schema.Tables.FirstOrDefault(t => fullKeyDbName == t.Name);
if (table == null)
{
bool ignoreCase = true;
table = schema.Tables.FirstOrDefault(t => 0 == string.Compare(fullKeyDbName, t.Name, ignoreCase));
if (table == null)
{
WriteErrorLine("ERROR L46: Table '" + keyColRow.TableName + "' not found for column " + keyColRow.ColumnName);
continue;
}
}
bool isForeignKey = keyColRow.ConstraintName != "PRIMARY"
&& keyColRow.ReferencedTableName != null;
if (isForeignKey)
{
LoadForeignKey(schema, table, keyColRow.ColumnName, keyColRow.TableName, keyColRow.TableSchema,
keyColRow.ReferencedColumnName, keyColRow.ReferencedTableName, keyColRow.ReferencedTableSchema,
keyColRow.ConstraintName, nameFormat, names);
}
}
}
protected override void LoadConstraints(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat, Names names)
{
//TableSorter.Sort(tables, constraints); //sort tables - parents first
var constraints = ReadConstraints(conn, schemaName.DbName);
var allKeys2 = ReadForeignConstraints(conn, schemaName.DbName);
var foreignKeys = allKeys2.Where(k => k.ConstraintType == "FOREIGN KEY").ToList();
var primaryKeys = allKeys2.Where(k => k.ConstraintType == "PRIMARY KEY").ToList();
foreach (DataConstraint keyColRow in constraints)
{
//find my table:
string constraintFullDbName = GetFullDbName(keyColRow.TableName, keyColRow.TableSchema);
DbLinq.Schema.Dbml.Table table = schema.Tables.FirstOrDefault(t => constraintFullDbName == t.Name);
if (table == null)
{
WriteErrorLine("ERROR L138: Table '" + keyColRow.TableName + "' not found for column " + keyColRow.ColumnName);
continue;
}
//todo: must understand better how PKEYs are encoded.
//In Sasha's DB, they don't end with "_pkey", you need to rely on ReadForeignConstraints().
//In Northwind, they do end with "_pkey".
bool isPrimaryKey = keyColRow.ConstraintName.EndsWith("_pkey")
|| primaryKeys.Count(k => k.ConstraintName == keyColRow.ConstraintName) == 1;
if (isPrimaryKey)
{
//A) add primary key
DbLinq.Schema.Dbml.Column primaryKeyCol = table.Type.Columns.First(c => c.Name == keyColRow.ColumnName);
primaryKeyCol.IsPrimaryKey = true;
}
else
{
DataForeignConstraint dataForeignConstraint = foreignKeys.FirstOrDefault(f => f.ConstraintName == keyColRow.ConstraintName);
if (dataForeignConstraint == null)
{
string msg = "Missing data from 'constraint_column_usage' for foreign key " + keyColRow.ConstraintName;
WriteErrorLine(msg);
//throw new ApplicationException(msg);
continue; //as per Andrus, do not throw. //putting together an Adnrus_DB test case.
}
LoadForeignKey(schema, table, keyColRow.ColumnName, keyColRow.TableName, keyColRow.TableSchema,
dataForeignConstraint.ColumnName, dataForeignConstraint.ReferencedTableName,
dataForeignConstraint.ReferencedTableSchema,
keyColRow.ConstraintName, nameFormat, names);
}
}
}
/// <summary>
/// Loads the foreign key.
/// </summary>
/// <param name="schema">The schema.</param>
/// <param name="table">The table.</param>
/// <param name="columnName">Name of the column.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="tableSchema">The table schema.</param>
/// <param name="referencedColumnName">Name of the referenced column.</param>
/// <param name="referencedTableName">Name of the referenced table.</param>
/// <param name="referencedTableSchema">The referenced table schema.</param>
/// <param name="constraintName">Name of the constraint.</param>
/// <param name="nameFormat">The name format.</param>
/// <param name="names">The names.</param>
protected virtual void LoadForeignKey(Database schema, Table table, string columnName, string tableName, string tableSchema,
string referencedColumnName, string referencedTableName, string referencedTableSchema,
string constraintName,
NameFormat nameFormat, Names names)
{
var foreignKey = BuildForeignKey(names.ColumnsNames[tableName], columnName);
var reverseForeignKey = BuildForeignKey(names.ColumnsNames[referencedTableName], referencedColumnName);
var associationName = CreateAssociationName(tableName, tableSchema,
referencedTableName, referencedTableSchema, constraintName, foreignKey, nameFormat);
//both parent and child table get an [Association]
var assoc = new Association();
assoc.IsForeignKey = true;
assoc.Name = constraintName;
assoc.Type = null;
assoc.ThisKey = foreignKey;
assoc.OtherKey = reverseForeignKey;
assoc.Member = associationName.ManyToOneMemberName;
assoc.CardinalitySpecified = false;
// TODO: generate assoc.Cardinality?
table.Type.Associations.Add(assoc);
//and insert the reverse association:
var reverseAssociation = new Association();
reverseAssociation.Name = constraintName;
reverseAssociation.Type = table.Type.Name;
reverseAssociation.Member = associationName.OneToManyMemberName;
reverseAssociation.CardinalitySpecified = false;
// TODO: generate reverseAssociation.Cardinality?
reverseAssociation.ThisKey = reverseForeignKey;
reverseAssociation.OtherKey = foreignKey;
reverseAssociation.DeleteRule = "NO ACTION";
string referencedFullDbName = GetFullDbName(referencedTableName, referencedTableSchema);
var referencedTable = schema.Tables.FirstOrDefault(t => referencedFullDbName == t.Name);
if (referencedTable == null)
{
//try case-insensitive match
//reason: MySql's Key_Column_Usage table contains both 'Northwind' and 'northwind'
referencedTable = schema.Tables.FirstOrDefault(t => referencedFullDbName.ToLower() == t.Name.ToLower());
}
if (referencedTable == null)
{
ReportForeignKeyError(schema, referencedFullDbName);
}
else
{
referencedTable.Type.Associations.Add(reverseAssociation);
assoc.Type = referencedTable.Type.Name;
}
}
protected override void LoadConstraints(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat, Names names)
{
var constraints = ReadConstraints(conn, schemaName.DbName);
foreach (DataConstraint constraint in constraints)
{
//find my table:
string constraintFullDbName = GetFullDbName(constraint.TableName, constraint.TableSchema);
DbLinq.Schema.Dbml.Table table = schema.Tables.FirstOrDefault(t => constraintFullDbName == t.Name);
if (table == null)
{
WriteErrorLine("ERROR L100: Table '" + constraint.TableName + "' not found for column " + constraint.ColumnNameList);
continue;
}
//if (table.Name.StartsWith("E"))
// Logger.Write("---Dbg");
if (constraint.ConstraintType == "P")
{
//A) add primary key
DbLinq.Schema.Dbml.Column pkColumn = table.Type.Columns.Where(c => constraint.ColumnNames.Contains(c.Name)).First();
pkColumn.IsPrimaryKey = true;
}
else if (constraint.ConstraintType == "R")
{
//if not PRIMARY, it's a foreign key. (constraint_type=="R")
//both parent and child table get an [Association]
DataConstraint referencedConstraint = constraints.FirstOrDefault(c => c.ConstraintName == constraint.ReverseConstraintName);
if (constraint.ReverseConstraintName == null || referencedConstraint == null)
{
WriteErrorLine("ERROR L127: given R_contraint_name='" + constraint.ReverseConstraintName + "', unable to find parent constraint");
continue;
}
LoadForeignKey(schema, table, constraint.ColumnNameList, constraint.TableName, constraint.TableSchema,
referencedConstraint.ColumnNameList, referencedConstraint.TableName,
referencedConstraint.TableSchema,
constraint.ConstraintName, nameFormat, names);
}
// custom type, this is a trigger
else if (constraint.ConstraintType == "T" && constraint.ColumnNames.Count == 1)
{
var column = table.Type.Columns.Where(c => c.Name == constraint.ColumnNames[0]).First();
column.Expression = constraint.Expression;
column.IsDbGenerated = true;
}
}
//GuessSequencePopulatedFields(schema);
}
/// <summary>
/// Loads database schema
/// </summary>
/// <param name="databaseName"></param>
/// <param name="nameAliases"></param>
/// <param name="nameFormat"></param>
/// <param name="loadStoredProcedures"></param>
/// <param name="contextNamespace"></param>
/// <param name="entityNamespace"></param>
/// <returns></returns>
public virtual Database Load(string databaseName, INameAliases nameAliases, NameFormat nameFormat,
bool loadStoredProcedures, string contextNamespace, string entityNamespace)
{
// check if connection is open. Note: we may use something more flexible
if (Connection.State != ConnectionState.Open)
Connection.Open();
// get the database name. If we don't have one, take it from connection string...
if (string.IsNullOrEmpty(databaseName))
databaseName = Connection.Database;
// ... and if connection string doesn't provide a name, then throw an error
if (string.IsNullOrEmpty(databaseName))
throw new ArgumentException("A database name is required. Please specify /database=<databaseName>");
databaseName = GetDatabaseNameAliased(databaseName, nameAliases);
var schemaName = NameFormatter.GetSchemaName(databaseName, GetExtraction(databaseName), nameFormat);
var names = new Names();
var schema = new Database
{
Name = schemaName.DbName,
Class = GetRuntimeClassName(schemaName.ClassName, nameAliases),
BaseType = typeof(DataContext).FullName,
ContextNamespace = contextNamespace,
EntityNamespace = entityNamespace,
};
// order is important, we must have:
// 1. tables
// 2. columns
// 3. constraints
LoadTables(schema, schemaName, Connection, nameAliases, nameFormat, names);
LoadColumns(schema, schemaName, Connection, nameAliases, nameFormat, names);
CheckColumnsName(schema);
LoadConstraints(schema, schemaName, Connection, nameFormat, names);
CheckConstraintsName(schema);
if (loadStoredProcedures)
LoadStoredProcedures(schema, schemaName, Connection, nameFormat);
// names aren't checked here anymore, because this confuses DBML editor.
// they will (for now) be checked before .cs generation
// in the end, when probably will end up in mapping source (or somewhere around)
//CheckNamesSafety(schema);
// generate backing fields name (since we have here correct names)
GenerateStorageAndMemberFields(schema);
return schema;
}
protected override void LoadConstraints(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat, Names names)
{
//TableSorter.Sort(tables, constraints); //sort tables - parents first
var foreignKeys = ReadConstraints(conn, schemaName.DbName);
foreach (DataConstraint keyColRow in foreignKeys)
{
//find my table:
string constraintFullDbName = GetFullDbName(keyColRow.TableName, keyColRow.TableSchema);
DbLinq.Schema.Dbml.Table table = schema.Tables.FirstOrDefault(t => constraintFullDbName == t.Name);
if (table == null)
{
WriteErrorLine("ERROR L138: Table '"
+ keyColRow.TableName
+ "' not found for column "
+ keyColRow.ColumnName);
continue;
}
if (keyColRow.ConstraintType.Equals("P")) //'PRIMARY KEY'
{
//foreach (string pk_name in keyColRow.column_name_primaries)
//{
DbLinq.Schema.Dbml.Column primaryKeyCol = table.Type.Columns.First(c => c.Name == keyColRow.ColumnName);
primaryKeyCol.IsPrimaryKey = true;
//}
continue;
}
if (keyColRow.ConstraintType.Equals("R")) //'FOREIGN KEY'
{
// This is very bad...
if (!names.ColumnsNames[keyColRow.ReferencedTableName].ContainsKey(keyColRow.ReferencedColumnName))
continue;
LoadForeignKey(schema, table, keyColRow.ColumnName, keyColRow.TableName,
keyColRow.TableSchema,
keyColRow.ReferencedColumnName, keyColRow.ReferencedTableName,
keyColRow.ReferencedTableSchema,
keyColRow.ConstraintName, nameFormat, names);
}
}
}
protected override void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
var parameters = ReadParameters(conn, schemaName.DbName);
foreach (var parameter in parameters)
{
var procedureName = CreateProcedureName(parameter.ProcedureName, parameter.Schema, nameFormat);
Function function = schema.Functions.SingleOrDefault(f => f.Method == procedureName.MethodName);
if (function == null)
{
function = new Function { Name = procedureName.DbName, Method = procedureName.MethodName };
schema.Functions.Add(function);
}
if (parameter.Name == null)
{
var returnParameter = new Return();
returnParameter.DbType = parameter.Type.SqlType;
returnParameter.Type = MapDbType(parameter.Name, parameter.Type).ToString();
function.IsComposable = true;
function.Return = returnParameter;
}
else
{
var functionParameter = new Parameter();
functionParameter.DbType = parameter.Type.SqlType;
functionParameter.Type = MapDbType(parameter.Name, parameter.Type).ToString();
if (parameter.In)
{
if (parameter.Out)
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.InOut;
else
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.In;
}
else
functionParameter.Direction = DbLinq.Schema.Dbml.ParameterDirection.Out;
var parameterName = CreateParameterName(parameter.Name, nameFormat);
functionParameter.Name = parameterName.CallName;
function.Parameters.Add(functionParameter);
}
}
}
public virtual Database Load(string databaseName, INameAliases nameAliases, NameFormat nameFormat,
bool loadStoredProcedures, string contextNamespace, string entityNamespace)
{
// check if connection is open. Note: we may use something more flexible
if (Connection.State != ConnectionState.Open)
Connection.Open();
// get the database name. If we don't have one, take it from connection string...
if (string.IsNullOrEmpty(databaseName))
databaseName = Connection.Database;
// ... and if connection string doesn't provide a name, then throw an error
if (string.IsNullOrEmpty(databaseName))
throw new ArgumentException("A database name is required. Please specify /database=<databaseName>");
var schemaName = NameFormatter.GetSchemaName(databaseName, GetExtraction(databaseName), nameFormat);
var names = new Names();
var schema = new Database
{
Name = schemaName.DbName,
Class = schemaName.ClassName,
BaseType = typeof(DataContext).FullName,
ContextNamespace = contextNamespace,
EntityNamespace = entityNamespace,
};
// order is important, we must have:
// 1. tables
// 2. columns
// 3. constraints
LoadTables(schema, schemaName, Connection, nameAliases, nameFormat, names);
LoadColumns(schema, schemaName, Connection, nameAliases, nameFormat, names);
LoadConstraints(schema, schemaName, Connection, nameFormat, names);
if (loadStoredProcedures)
LoadStoredProcedures(schema, schemaName, Connection, nameFormat);
CheckNamesCaseSafety(schema);
// check for duplicate names between properties
CheckNames(schema);
// generate backing fields name (since we have here correct names)
GenerateStorageFields(schema);
return schema;
}
protected override void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
var procs = ReadProcedures(conn, schemaName.DbName);
foreach (DataStoredProcedure proc in procs)
{
var procedureName = CreateProcedureName(proc.specific_name, proc.db, nameFormat);
var func = new Function();
func.Name = procedureName.DbName;
func.Method = procedureName.MethodName;
func.IsComposable = string.Compare(proc.type, "FUNCTION") == 0;
func.BodyContainsSelectStatement = proc.body != null
&& proc.body.IndexOf("select", StringComparison.OrdinalIgnoreCase) > -1;
ParseProcParams(proc, func);
schema.Functions.Add(func);
}
}
protected override void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
var procs = ReadProcedures(conn, schemaName.DbName);
//4a. determine unknown types
Dictionary<long, string> typeOidToName = new Dictionary<long, string>();
foreach (DataStoredProcedure proc in procs)
{
if (proc.proallargtypes == null && !string.IsNullOrEmpty(proc.proargtypes))
proc.proallargtypes = "{" + proc.proargtypes.Replace(' ', ',') + "}"; //work around pgsql weirdness?
}
foreach (DataStoredProcedure proc in procs)
{
typeOidToName[proc.prorettype] = proc.formatted_prorettype;
if (proc.proallargtypes == null)
continue; //no args, no Oids to resolve, skip
string[] argTypes1 = parseCsvString(proc.proallargtypes); //eg. {23,24,1043}
var argTypes2 = from t in argTypes1 select long.Parse(t);
foreach (long argType in argTypes2)
{
if (!typeOidToName.ContainsKey(argType))
typeOidToName[argType] = null;
}
}
//4b. get names for unknown types
GetTypeNames(conn, schemaName.DbName, typeOidToName);
//4c. generate dbml objects
foreach (DataStoredProcedure proc in procs)
{
DbLinq.Schema.Dbml.Function dbml_fct = ParseFunction(proc, typeOidToName, nameFormat);
if (!SkipProc(dbml_fct.Name))
schema.Functions.Add(dbml_fct);
}
}
protected override void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
// TODO: debug stored procedures support
return;
var procs = ReadProcedures(conn, schemaName.DbName);
foreach (DataStoredProcedure proc in procs)
{
var procedureName = CreateProcedureName(proc.Name, proc.TableSchema, nameFormat);
var func = new Function();
func.Name = procedureName.DbName;
func.Method = procedureName.MethodName;
func.IsComposable = string.Compare(proc.Type, "FUNCTION") == 0;
func.BodyContainsSelectStatement = proc.BodyContainsSelectStatement;
ParseProcParams(proc, func);
schema.Functions.Add(func);
}
}
/// <summary>
/// Loads the columns.
/// </summary>
/// <param name="schema">The schema.</param>
/// <param name="schemaName">Name of the schema.</param>
/// <param name="conn">The conn.</param>
/// <param name="nameAliases">The name aliases.</param>
/// <param name="nameFormat">The name format.</param>
/// <param name="names">The names.</param>
protected void LoadColumns(Database schema, SchemaName schemaName, IDbConnection conn, INameAliases nameAliases, NameFormat nameFormat, Names names)
{
var columnRows = ReadColumns(conn, schemaName.DbName);
foreach (var columnRow in columnRows)
{
var columnName = CreateColumnName(columnRow.ColumnName, columnRow.TableName, columnRow.TableSchema, nameAliases, nameFormat);
names.AddColumn(columnRow.TableName, columnName);
//find which table this column belongs to
string fullColumnDbName = GetFullDbName(columnRow.TableName, columnRow.TableSchema);
DbLinq.Schema.Dbml.Table tableSchema = schema.Tables.FirstOrDefault(tblSchema => fullColumnDbName == tblSchema.Name);
if (tableSchema == null)
{
WriteErrorLine("ERROR L46: Table '" + columnRow.TableName + "' not found for column " + columnRow.ColumnName);
continue;
}
var column = new Column();
column.Name = columnName.DbName;
column.Member = columnName.PropertyName;
column.DbType = columnRow.FullType;
if (columnRow.PrimaryKey.HasValue)
column.IsPrimaryKey = columnRow.PrimaryKey.Value;
bool? generated = (nameAliases != null) ? nameAliases.GetColumnGenerated(columnRow.ColumnName, columnRow.TableName, columnRow.TableSchema) : null;
if (!generated.HasValue)
generated = columnRow.Generated;
if (generated.HasValue)
column.IsDbGenerated = generated.Value;
AutoSync? autoSync = (nameAliases != null) ? nameAliases.GetColumnAutoSync(columnRow.ColumnName, columnRow.TableName, columnRow.TableSchema) : null;
if (autoSync.HasValue)
column.AutoSync = autoSync.Value;
// the Expression can originate from two sources:
// 1. DefaultValue
// 2. Expression
// we use any valid source (we can't have both)
if (column.IsDbGenerated && columnRow.DefaultValue != null)
column.Expression = columnRow.DefaultValue;
column.CanBeNull = columnRow.Nullable;
string columnTypeAlias = nameAliases != null ? nameAliases.GetColumnForcedType(columnRow.ColumnName, columnRow.TableName, columnRow.TableSchema) : null;
var columnType = MapDbType(columnName.DbName, columnRow);
var columnEnumType = columnType as EnumType;
if (columnEnumType != null)
{
var enumType = column.SetExtendedTypeAsEnumType();
enumType.Name = columnEnumType.Name;
foreach (KeyValuePair<string, int> enumValue in columnEnumType.EnumValues)
{
enumType[enumValue.Key] = enumValue.Value;
}
}
else if (columnTypeAlias != null)
column.Type = columnTypeAlias;
else
column.Type = columnType.ToString();
tableSchema.Type.Columns.Add(column);
}
}
public TableName GetTableName(string dbName, WordsExtraction extraction, NameFormat nameFormat)
{
var words = GetLanguageWords(nameFormat.Culture);
var tableName = new TableName { DbName = dbName };
tableName.NameWords = ExtractWords(words, dbName, extraction);
// if no extraction (preset name, just copy it)
if (extraction == WordsExtraction.None)
tableName.ClassName = tableName.DbName;
else
tableName.ClassName = Format(words, tableName.NameWords, nameFormat.Case, GetSingularization(Singularization.Singular, nameFormat));
tableName.MemberName = Format(words, tableName.NameWords, nameFormat.Case, GetSingularization(Singularization.Plural, nameFormat));
return tableName;
}
protected virtual ParameterName CreateParameterName(string dbParameterName, NameFormat nameFormat)
{
var parameterName = NameFormatter.GetParameterName(dbParameterName, GetExtraction(dbParameterName), nameFormat);
return parameterName;
}
/// <summary>
/// Loads the tables in the given schema.
/// </summary>
/// <param name="schema">The schema.</param>
/// <param name="schemaName">Name of the schema.</param>
/// <param name="conn">The conn.</param>
/// <param name="nameAliases">The name aliases.</param>
/// <param name="nameFormat">The name format.</param>
/// <param name="names">The names.</param>
protected virtual void LoadTables(Database schema, SchemaName schemaName, IDbConnection conn, INameAliases nameAliases, NameFormat nameFormat, Names names)
{
var tables = ReadTables(conn, schemaName.DbName);
foreach (var row in tables)
{
var tableName = CreateTableName(row.Name, row.Schema, nameAliases, nameFormat);
names.TablesNames[tableName.DbName] = tableName;
var table = new Table();
table.Name = tableName.DbName;
table.Member = tableName.MemberName;
table.Type.Name = tableName.ClassName;
schema.Tables.Add(table);
}
}
/// <summary>
/// Creates the name of the association.
/// </summary>
/// <param name="dbManyName">Name of the db many.</param>
/// <param name="dbManySchema">The db many schema.</param>
/// <param name="dbOneName">Name of the db one.</param>
/// <param name="dbOneSchema">The db one schema.</param>
/// <param name="dbConstraintName">Name of the db constraint.</param>
/// <param name="foreignKeyName">Name of the foreign key.</param>
/// <param name="nameFormat">The name format.</param>
/// <returns></returns>
protected virtual AssociationName CreateAssociationName(string dbManyName, string dbManySchema,
string dbOneName, string dbOneSchema, string dbConstraintName, string foreignKeyName, NameFormat nameFormat)
{
var associationName = NameFormatter.GetAssociationName(dbManyName, dbOneName,
dbConstraintName, foreignKeyName, GetExtraction(dbManyName), nameFormat);
associationName.DbName = GetFullDbName(dbManyName, dbManySchema);
return associationName;
}
/// <summary>
/// Creates the name of the schema.
/// </summary>
/// <param name="databaseName">Name of the database.</param>
/// <param name="connection">The connection.</param>
/// <param name="nameFormat">The name format.</param>
/// <returns></returns>
protected virtual SchemaName CreateSchemaName(string databaseName, IDbConnection connection, NameFormat nameFormat)
{
if (string.IsNullOrEmpty(databaseName))
{
databaseName = connection.Database;
if (string.IsNullOrEmpty(databaseName))
throw new ArgumentException("Could not deduce database name from connection string. Please specify /database=<databaseName>");
}
return NameFormatter.GetSchemaName(databaseName, GetExtraction(databaseName), nameFormat);
}
/// <summary>
/// Creates the name of the column.
/// </summary>
/// <param name="dbColumnName">Name of the db column.</param>
/// <param name="dbTableName">Name of the db table.</param>
/// <param name="dbSchema">The db schema.</param>
/// <param name="nameAliases">The name aliases.</param>
/// <param name="nameFormat">The name format.</param>
/// <returns></returns>
protected virtual ColumnName CreateColumnName(string dbColumnName, string dbTableName, string dbSchema, INameAliases nameAliases, NameFormat nameFormat)
{
var columnNameAlias = nameAliases != null ? nameAliases.GetColumnMemberAlias(dbColumnName, dbTableName, dbSchema) : null;
WordsExtraction extraction;
if (columnNameAlias != null)
{
extraction = WordsExtraction.None;
}
else
{
extraction = GetExtraction(dbColumnName);
columnNameAlias = dbColumnName;
}
var columnName = NameFormatter.GetColumnName(columnNameAlias, extraction, nameFormat);
// The member name can not be the same as the class
// we add a "1" (just like SqlMetal does)
var tableName = CreateTableName(dbTableName, dbSchema, nameAliases, nameFormat);
if (columnName.PropertyName == tableName.ClassName)
columnName.PropertyName = columnName.PropertyName + "1";
columnName.DbName = dbColumnName;
return columnName;
}
Function ParseFunction(DataStoredProcedure pg_proc, Dictionary<long, string> typeOidToName, NameFormat nameFormat)
{
var procedureName = CreateProcedureName(pg_proc.proname, null, nameFormat);
DbLinq.Schema.Dbml.Function dbml_func = new Function();
dbml_func.Name = procedureName.DbName;
dbml_func.Method = procedureName.MethodName;
if (pg_proc.formatted_prorettype != null && string.Compare(pg_proc.formatted_prorettype, "void") != 0)
{
var dbml_param = new Return();
dbml_param.DbType = pg_proc.formatted_prorettype;
dbml_param.Type = MapDbType(null, new DataType { SqlType = pg_proc.formatted_prorettype }).ToString();
dbml_func.Return = dbml_param;
dbml_func.IsComposable = true;
}
if (pg_proc.proallargtypes != null)
{
string[] argModes = parseCsvString(pg_proc.proargmodes);
string[] argNames = parseCsvString(pg_proc.proargnames);
string[] argTypes1 = parseCsvString(pg_proc.proallargtypes); //eg. {23,24,1043}
List<long> argTypes2 = (from t in argTypes1 select long.Parse(t)).ToList();
if (argNames == null)
{
//proc was specified as 'FUNCTION doverlaps(IN date)' - names not specified
argNames = new string[argTypes1.Length];
for (int i = 0; i < argNames.Length; i++) { argNames[i] = ((char)('a' + i)).ToString(); }
}
bool doLengthsMatch = (argTypes2.Count != argNames.Length
|| (argModes != null && argModes.Length != argNames.Length));
if (doLengthsMatch)
{
WriteErrorLine("L238 Mistmatch between modesArr, typeArr and nameArr for func " + pg_proc.proname);
return null;
}
for (int i = 0; i < argNames.Length; i++)
{
DbLinq.Schema.Dbml.Parameter dbml_param = new Parameter();
long argTypeOid = argTypes2[i];
dbml_param.DbType = typeOidToName[argTypeOid];
dbml_param.Name = argNames[i];
dbml_param.Type = MapDbType(argNames[i], new DataType { SqlType = dbml_param.DbType }).ToString();
string inOut = argModes == null ? "i" : argModes[i];
dbml_param.Direction = ParseInOut(inOut);
dbml_func.Parameters.Add(dbml_param);
}
}
return dbml_func;
}
/// <summary>
/// Creates the name of the table given a name and schema
/// </summary>
/// <param name="dbTableName">Name of the db table.</param>
/// <param name="dbSchema">The db schema.</param>
/// <param name="nameAliases">The name aliases.</param>
/// <param name="nameFormat">The name format.</param>
/// <param name="extraction">The extraction.</param>
/// <returns></returns>
protected virtual TableName CreateTableName(string dbTableName, string dbSchema, INameAliases nameAliases, NameFormat nameFormat, WordsExtraction extraction)
{
// if we have an alias, use it, and don't try to analyze it (a human probably already did the job)
var tableTypeAlias = nameAliases != null ? nameAliases.GetTableTypeAlias(dbTableName, dbSchema) : null;
if (tableTypeAlias != null)
extraction = WordsExtraction.None;
else
tableTypeAlias = dbTableName;
var tableName = NameFormatter.GetTableName(tableTypeAlias, extraction, nameFormat);
// alias for member
var tableMemberAlias = nameAliases != null ? nameAliases.GetTableMemberAlias(dbTableName, dbSchema) : null;
if (tableMemberAlias != null)
tableName.MemberName = tableMemberAlias;
tableName.DbName = GetFullDbName(dbTableName, dbSchema);
return tableName;
}
protected virtual ColumnName CreateColumnName(string dbColumnName, string dbTableName, string dbSchema, INameAliases nameAliases, NameFormat nameFormat)
{
var columnNameAlias = nameAliases != null ? nameAliases.GetColumnMemberAlias(dbColumnName, dbTableName, dbSchema) : null;
WordsExtraction extraction;
if (columnNameAlias != null)
{
extraction = WordsExtraction.None;
}
else
{
extraction = GetExtraction(dbColumnName);
columnNameAlias = dbColumnName;
}
var columnName = NameFormatter.GetColumnName(columnNameAlias, extraction, nameFormat);
columnName.DbName = dbColumnName;
return columnName;
}
public ParameterName GetParameterName(string dbName, WordsExtraction extraction, NameFormat nameFormat)
{
var words = GetLanguageWords(nameFormat.Culture);
var parameterName = new ParameterName { DbName = dbName };
parameterName.NameWords = ExtractWords(words, dbName, extraction);
parameterName.CallName = Format(words, parameterName.NameWords, Case.camelCase, Singularization.DontChange);
return parameterName;
}
public ColumnName GetColumnName(string dbName, WordsExtraction extraction, NameFormat nameFormat)
{
var words = GetLanguageWords(nameFormat.Culture);
var columnName = new ColumnName { DbName = dbName };
columnName.NameWords = ExtractWords(words, dbName, extraction);
// if no extraction (preset name, just copy it)
if (extraction == WordsExtraction.None)
columnName.PropertyName = dbName;
else
columnName.PropertyName = Format(words, columnName.NameWords, nameFormat.Case, Singularization.DontChange);
return columnName;
}
/// <summary> /// Loads the constraints. /// </summary> /// <param name="schema">The schema.</param> /// <param name="schemaName">Name of the schema.</param> /// <param name="conn">The conn.</param> /// <param name="nameFormat">The name format.</param> /// <param name="names">The names.</param> protected abstract void LoadConstraints(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat, Names names);
protected override TableName CreateTableName(string dbTableName, string dbSchema, INameAliases nameAliases, NameFormat nameFormat)
{
return CreateTableName(dbTableName, dbSchema, nameAliases, nameFormat, WordsExtraction.FromDictionary);
}
/// <summary>
/// Creates the name of the procedure.
/// </summary>
/// <param name="dbProcedureName">Name of the db procedure.</param>
/// <param name="dbSchema">The db schema.</param>
/// <param name="nameFormat">The name format.</param>
/// <returns></returns>
protected virtual ProcedureName CreateProcedureName(string dbProcedureName, string dbSchema, NameFormat nameFormat)
{
var procedureName = NameFormatter.GetProcedureName(dbProcedureName, GetExtraction(dbProcedureName), nameFormat);
procedureName.DbName = GetFullDbName(dbProcedureName, dbSchema);
return procedureName;
}
protected virtual TableName CreateTableName(string dbTableName, string dbSchema, INameAliases nameAliases, NameFormat nameFormat)
{
return CreateTableName(dbTableName, dbSchema, nameAliases, nameFormat, GetExtraction(dbTableName));
}
public AssociationName GetAssociationName(string dbManyName, string dbOneName, string dbConstraintName,
string foreignKeyName, WordsExtraction extraction, NameFormat nameFormat)
{
var words = GetLanguageWords(nameFormat.Culture);
var associationName = new AssociationName { DbName = dbManyName };
associationName.NameWords = ExtractWords(words, dbManyName, extraction);
associationName.ManyToOneMemberName = Format(words, dbOneName, nameFormat.Case, GetSingularization(Singularization.Singular, nameFormat));
// TODO: this works only for PascalCase
if (dbManyName == dbOneName)
associationName.ManyToOneMemberName = foreignKeyName + associationName.ManyToOneMemberName;
// TODO: support new extraction
associationName.OneToManyMemberName = Format(words, dbManyName, nameFormat.Case, GetSingularization(Singularization.Plural, nameFormat));
return associationName;
}
protected virtual void LoadStoredProcedures(Database schema, SchemaName schemaName, IDbConnection conn, NameFormat nameFormat)
{
}
public ProcedureName GetProcedureName(string dbName, WordsExtraction extraction, NameFormat nameFormat)
{
var words = GetLanguageWords(nameFormat.Culture);
var procedureName = new ProcedureName { DbName = dbName };
procedureName.NameWords = ExtractWords(words, dbName, extraction);
procedureName.MethodName = Format(words, procedureName.NameWords, nameFormat.Case, Singularization.DontChange);
return procedureName;
}
