DataModel.ttinclude

<#@ assembly name="System.Data"                #>
<#@ import namespace="System.Data"             #>
<#@ import namespace="LinqToDB.SchemaProvider" #>
<#@ import namespace="LinqToDB.Data"           #>
<#@ include file="T4Model.ttinclude"           #>
<#
	{
		var beforeGenerateModel = BeforeGenerateModel;
		BeforeGenerateModel = () =>
		{
			GenerateTypesFromMetadata();
			beforeGenerateModel();
		};
	}
#><#+

string   NamespaceName
{
	get { return Model.Namespace.Name;  }
	set { Model.Namespace.Name = value; }
}

string   DatabaseName                  = null;
string   DataContextName               = null;
string   BaseDataContextClass          = null;
string   BaseEntityClass               = null;
string   OneToManyAssociationType      = "IEnumerable<{0}>";

bool     GenerateDatabaseName          = false;
bool     GenerateConstructors          = true;
string   DefaultConfiguration          = null;
bool     GenerateAssociations          = true;
bool     GenerateBackReferences        = true;
bool     GenerateAssociationExtensions = false;
bool     ReplaceSimilarTables          = true;
bool     IncludeDefaultSchema          = true;

Class    DataContextObject;

bool PluralizeClassNames                 = false;
bool SingularizeClassNames               = true;
bool PluralizeDataContextPropertyNames   = true;
bool SingularizeDataContextPropertyNames = false;

bool NormalizeNames                      = true;

private Func<string, bool, string> _toValidName;
Func<string, bool, string> ToValidName
{
	get { return _toValidName ?? ToValidNameDefault; }
	set { _toValidName = value; }
}

private Func<string, bool, string> _convertToCompilabl;
Func<string, bool, string> ConvertToCompilable 
{
	get { return _convertToCompilabl ?? ConvertToCompilableDefault; }
	set { _convertToCompilabl = value; }
}

private Func<ForeignKey, string> _getAssociationExtensionPluralName;
Func<ForeignKey, string> GetAssociationExtensionPluralName
{
	get { return _getAssociationExtensionPluralName ?? GetAssociationExtensionPluralNameDefault; }
	set { _getAssociationExtensionPluralName = value; }
}

private Func<ForeignKey, string> _getAssociationExtensionSingularName;
Func<ForeignKey, string> GetAssociationExtensionSinglularName
{
	get { return _getAssociationExtensionSingularName ?? GetAssociationExtensionSinglularNameDefault; }
	set { _getAssociationExtensionSingularName = value; }
}

LinqToDB.SchemaProvider.GetSchemaOptions GetSchemaOptions =
	new LinqToDB.SchemaProvider.GetSchemaOptions();

LinqToDB.SqlProvider.ISqlBuilder SqlBuilder;

Func<TableSchema,Table> LoadProviderSpecificTable = tableSchema => null;

static Func<ColumnSchema,string>                 ConvertColumnMemberType          = (c) => c.MemberType;
static Func<TableSchema,ColumnSchema,string>     ConvertTableColumnMemberType     = (t,c) => ConvertColumnMemberType(c);
static Func<ProcedureSchema,ColumnSchema,string> ConvertProcedureColumnMemberType = (t,c) => ConvertColumnMemberType(c);

HashSet<string> KeyWords = new HashSet<string>
{
	"abstract", "as",       "base",     "bool",    "break",     "byte",     "case",       "catch",     "char",    "checked",
	"class",    "const",    "continue", "decimal", "default",   "delegate", "do",         "double",    "else",    "enum",
	"event",    "explicit", "extern",   "false",   "finally",   "fixed",    "float",      "for",       "foreach", "goto",
	"if",       "implicit", "in",       "int",     "interface", "internal", "is",         "lock",      "long",    "new",
	"null",     "object",   "operator", "out",     "override",  "params",   "private",    "protected", "public",  "readonly",
	"ref",      "return",   "sbyte",    "sealed",  "short",     "sizeof",   "stackalloc", "static",    "struct",  "switch",
	"this",     "throw",    "true",     "try",     "typeof",    "uint",     "ulong",      "unchecked", "unsafe",  "ushort",
	"using",    "virtual",  "volatile", "void",    "while",     "namespace", "string"
};

void LoadServerMetadata(DataConnection dataConnection)
{
	SqlBuilder = dataConnection.DataProvider.CreateSqlBuilder();

	var sp = dataConnection.DataProvider.GetSchemaProvider();
	var db = sp.GetSchema(dataConnection, GetSchemaOptions);

	if (DatabaseName == null && GenerateDatabaseName)
		DatabaseName = db.Database;

	if (DataContextName == null)
		DataContextObject.Name = DataContextName = (ToValidName(db.Database, true) + "DB");

	DataContextObject.Comment.Add("/ <summary>");
	DataContextObject.Comment.Add("/ Database       : " + db.Database);
	DataContextObject.Comment.Add("/ Data Source    : " + db.DataSource);
	DataContextObject.Comment.Add("/ Server Version : " + db.ServerVersion);
	DataContextObject.Comment.Add("/ </summary>");

	var tables = db.Tables
		.Where(t => !t.IsProviderSpecific)
		.Select(t => new
		{
			t,
			key = t.IsDefaultSchema ? t.TableName : t.SchemaName + "." + t.TableName,
			table = new Table
			{
				TableSchema             = t,
				Schema                  = (t.IsDefaultSchema && !IncludeDefaultSchema) || string.IsNullOrEmpty(t.SchemaName)? null : t.SchemaName,
				BaseClass               = BaseEntityClass,
				TableName               = t.TableName,
				TypeName                = t.TypeName,
				DataContextPropertyName = t.TypeName,
				IsView                  = t.IsView,
				IsProviderSpecific      = false,
				Description             = t.Description,
				Columns                 = t.Columns.ToDictionary(
					c => c.ColumnName,
					c => new Column
					{
						ColumnName      = c.ColumnName,
						ColumnType      = c.ColumnType,
						DataType        = "DataType." + c.DataType,
						Length          = c.Length,
						Precision       = c.Precision,
						Scale           = c.Scale,
						IsNullable      = c.IsNullable,
						IsIdentity      = c.IsIdentity,
						IsPrimaryKey    = c.IsPrimaryKey,
						PrimaryKeyOrder = c.PrimaryKeyOrder,
						MemberName      = CheckType(c.SystemType, c.MemberName),
						Type            = ConvertTableColumnMemberType(t, c),
						SkipOnInsert    = c.SkipOnInsert,
						SkipOnUpdate    = c.SkipOnUpdate,
						Description     = c.Description,
					})
			}
		})
		.ToList();

	if (PluralizeClassNames || SingularizeClassNames)
	{
		var foundNames = new HashSet<string>(tables.Select(t => t.table.TypeName));
		foreach (var t in tables)
		{
			var newName = t.table.TypeName;
				newName = 
					PluralizeClassNames   ? ToPlural  (newName) :
					SingularizeClassNames ? ToSingular(newName) : newName;

			if (newName != t.table.TypeName)
			{
				if (!foundNames.Contains(newName))
				{
					t.table.TypeName = newName;
					foundNames.Add(newName);
				}
			}
		}
	}

	if (PluralizeDataContextPropertyNames || SingularizeDataContextPropertyNames)
	{
		var foundNames = new HashSet<string>(tables.Select(t => t.table.DataContextPropertyName));
		foreach (var t in tables)
		{
			var newName = t.table.DataContextPropertyName;
				newName = 
					PluralizeDataContextPropertyNames   ? ToPlural  (newName) :
					SingularizeDataContextPropertyNames ? ToSingular(newName) : newName;

			if (newName != t.table.TypeName)
			{
				if (!foundNames.Contains(newName))
				{
					t.table.DataContextPropertyName = newName;
					foundNames.Add(newName);
				}
			}
		}
	}

	tables.AddRange(db.Tables
		.Where(t => t.IsProviderSpecific)
		.Select(t => new
		{
			t,
			key = t.IsDefaultSchema ? t.TableName : t.SchemaName + "." + t.TableName,
			table = LoadProviderSpecificTable(t)
		})
		.Where(t => t.table != null));

	foreach (var t in tables)
		Tables.Add(t.key, t.table);

	var keys =
	(
		from t in tables
		from k in t.t.ForeignKeys
		let otherTable = tables.Where(tbl => tbl.t == k.OtherTable).Select(tbl => tbl.table).Single()
		select new
		{
			k,
			k.KeyName,
			t,
			key = new ForeignKey
			{
				KeyName         = k.KeyName,
				OtherTable      = otherTable,
				OtherColumns    = k.OtherColumns.Select(c => otherTable.Columns[c.ColumnName]).ToList(),
				ThisColumns     = k.ThisColumns. Select(c => t.table.   Columns[c.ColumnName]).ToList(),
				CanBeNull       = k.CanBeNull,
				MemberName      = k.MemberName,
				AssociationType = (AssociationType)(int)k.AssociationType,
			}
		}
	).ToList();

	foreach (var key in keys)
	{
	    var keyName = key.k.OtherTable.IsDefaultSchema ? key.KeyName : key.k.OtherTable.SchemaName + "." + key.KeyName;
		ForeignKey foundKey;
		if (key.t.table.ForeignKeys.TryGetValue(keyName, out foundKey))
		{
			key.t.table.ForeignKeys.Remove(keyName);
			key.t.table.ForeignKeys.Add(foundKey.OtherTable.TableName + "." + keyName, foundKey);
			keyName = key.k.OtherTable.TableName + "." + keyName;
		}

		key.t.table.ForeignKeys.Add(
			key.k.OtherTable.IsDefaultSchema ? key.KeyName : key.k.OtherTable.SchemaName + "." + key.KeyName,
			key.key);

		if (key.k.BackReference != null)
			key.key.BackReference = keys.First(k => k.k == key.k.BackReference).key;
	}

	var procedures = db.Procedures
		.Select(p => new
		{
			p,
			key = p.IsDefaultSchema ? p.ProcedureName : p.SchemaName + "." + p.ProcedureName,
			proc = new Procedure
			{
				Schema          = (p.IsDefaultSchema && !IncludeDefaultSchema) || string.IsNullOrEmpty(p.SchemaName)? null : p.SchemaName,
				ProcedureName   = p.ProcedureName,
				Name            = ToValidName(p.MemberName, true),
				IsFunction      = p.IsFunction,
				IsTableFunction = p.IsTableFunction,
				IsDefaultSchema = p.IsDefaultSchema,
				IsLoaded        = p.IsLoaded,
				ResultTable     = p.ResultTable == null ? null :
					new Table
					{
						TypeName = ToValidName(
							PluralizeClassNames   ? ToPlural  (p.ResultTable.TypeName) :
							SingularizeClassNames ? ToSingular(p.ResultTable.TypeName) : p.ResultTable.TypeName, true),
						Columns  = ToDictionary(
							p.ResultTable.Columns,
							c => c.ColumnName,
							c => new Column
							{
								ColumnName      = c.ColumnName,
								ColumnType      = c.ColumnType,
								IsNullable      = c.IsNullable,
								IsIdentity      = c.IsIdentity,
								IsPrimaryKey    = c.IsPrimaryKey,
								PrimaryKeyOrder = c.PrimaryKeyOrder,
								MemberName      = CheckColumnName(CheckType(c.SystemType, c.MemberName)),
								Type            = ConvertProcedureColumnMemberType(p, c),
								SkipOnInsert    = c.SkipOnInsert,
								SkipOnUpdate    = c.SkipOnUpdate,
								Description     = c.Description,
							},
							(c,n) =>
							{
								c.IsDuplicateOrEmpty = true;
								return "$" + (c.MemberName = "Column" + n);
							})
					},
				ResultException = p.ResultException,
				SimilarTables   = p.SimilarTables == null ? new List<Table>() :
					p.SimilarTables
						.Select(t => tables.Single(tbl => tbl.t == t).table)
						.ToList(),
				ProcParameters  = p.Parameters
					.Select(pr => new Parameter
					{
						SchemaName    = pr.SchemaName,
						SchemaType    = pr.SchemaType,
						IsIn          = pr.IsIn,
						IsOut         = pr.IsOut,
						IsResult      = pr.IsResult,
						Size          = pr.Size,
						ParameterName = CheckParameterName(pr.ParameterName),
						ParameterType = pr.ParameterType,
						SystemType    = pr.SystemType,
						DataType      = pr.DataType.ToString(),
					})
					.ToList(),
			}
		})
		.ToList();

	foreach (var p in procedures)
	{
		if (ReplaceSimilarTables)
			if (p.proc.SimilarTables.Count() == 1 || p.proc.SimilarTables.Count(t => !t.IsView) == 1)
				p.proc.ResultTable = p.proc.SimilarTables.Count() == 1 ?
					p.proc.SimilarTables[0] :
					p.proc.SimilarTables.First(t => !t.IsView);

		Procedures[p.key] = p.proc;
	}
}

Dictionary<string,TR> ToDictionary<T,TR>(IEnumerable<T> source, Func<T,string> keyGetter, Func<T,TR> objGetter, Func<TR,int,string> getKeyName)
{
	var dic     = new Dictionary<string,TR>();
	var current = 1;

	foreach (var item in source)
	{
		var key = keyGetter(item);
		var obj = objGetter(item);

		if (string.IsNullOrEmpty(key) || dic.ContainsKey(key))
			key = getKeyName(obj, current);

		dic.Add(key, obj);

		current++;
	}

	return dic;
}

string CheckType(Type type, string typeName)
{
	if (!Model.Usings.Contains(type.Namespace))
		Model.Usings.Add(type.Namespace);
	return typeName;
}

string CheckColumnName(string memberName)
{
    if (string.IsNullOrEmpty(memberName))
        memberName = "Empty";
    else
    {
        memberName = memberName
			.Replace("%", "Percent")
			.Replace(">", "Greater")
			.Replace("<", "Lower")
			.Replace("+", "Plus")
			.Replace('(', '_')
			.Replace(')', '_')
			.Replace('-', '_')
			.Replace('|', '_')
			.Replace(',', '_')
			.Replace('"', '_')
			.Replace("'", "_")
			.Replace(".", "_")
			.Replace("\u00A3", "Pound");
	
		if (KeyWords.Contains(memberName))
			memberName = "@" + memberName;
    }
    return memberName;
}

string CheckParameterName(string parameterName)
{
    var invalidParameterNames = new List<string>
    {
        "@DataType"
    };

    var result = parameterName;
    while (invalidParameterNames.Contains(result))
    {
        result = result + "_";
    }
	return result;
}

Action AfterLoadMetadata = () => {};

void LoadMetadata(DataConnection dataConnection)
{
	if (DataContextObject == null)
	{
		DataContextObject = new Class(DataContextName) { BaseClass = BaseDataContextClass, };

		Model.Types.Add(DataContextObject);
	}

	LoadServerMetadata(dataConnection);

	if (Tables.Values.SelectMany(_ => _.ForeignKeys.Values).Any(_ => _.AssociationType == AssociationType.OneToMany))
		Model.Usings.Add("System.Collections.Generic");

	foreach (var t in Tables.Values)
	{
		if (KeyWords.Contains(t.TypeName))
			t.TypeName = "@" + t.TypeName;

		if (KeyWords.Contains(t.DataContextPropertyName))
			t.DataContextPropertyName = "@" + t.DataContextPropertyName;

		t.TypeName                = ConvertToCompilable(t.TypeName,                true);
		t.DataContextPropertyName = ConvertToCompilable(t.DataContextPropertyName, true);

		foreach (var col in t.Columns.Values)
		{
			if (KeyWords.Contains(col.MemberName))
				col.MemberName = "@" + col.MemberName;

			col.MemberName = ConvertToCompilable(col.MemberName, true);

			if (col.MemberName == t.TypeName)
				col.MemberName += "_Column";
		}
	}

	foreach (var t in Tables.Values)
	{
		foreach (var fk in t.ForeignKeys.Values)
		{
			var memberName = fk.OtherTable.TypeName;

			memberName = fk.AssociationType == AssociationType.OneToMany ?
				ToPlural(memberName) : ToSingular(memberName);

			fk.MemberName = memberName;
		}
	}

	foreach (var t in Tables.Values)
	{
		var forbidden = KeyWords.Concat(new [] {t.TypeName});

		var hasDuplicates = t.Columns.Values
				.Select(c => c.MemberName)
				.Concat(t.ForeignKeys.Values.Select(f => f.MemberName))
				.Concat(forbidden)
				.ToLookup(n => n)
				.Any(g => g.Count() > 1);
				
		if (hasDuplicates)
		{
			foreach (var fk in t.ForeignKeys.Values)
			{
				var mayDuplicate = t.Columns.Values
					.Select(c => c.MemberName)
					.Concat(forbidden)
					.Concat(t.ForeignKeys.Values.Where(f => f != fk).Select(f => f.MemberName));

				fk.MemberName = SuggestNoDuplicate(mayDuplicate, fk.MemberName, "FK");
			}

			foreach (var col in t.Columns.Values)
			{
				var mayDuplicate = t.Columns.Values
					.Where(c => c != col)
					.Select(c => c.MemberName)
					.Concat(forbidden)
					.Concat(t.ForeignKeys.Values.Select(fk => fk.MemberName));

				col.MemberName = SuggestNoDuplicate(mayDuplicate, col.MemberName, null);
			}
		}
	}

	AfterLoadMetadata();
}

string SuggestNoDuplicate(IEnumerable<string> currentNames, string newName, string prefix)
{
	var names = new HashSet<string>(currentNames);
	var result = newName;
	if (names.Contains(result))
	{
		if (!string.IsNullOrEmpty(prefix))
			result = prefix + result;
		if (names.Contains(result))
		{
			var counter = 0;
			var number = string.Concat(result.Reverse().Take(6).TakeWhile(c => Char.IsDigit(c)).Reverse());
			if (!string.IsNullOrEmpty(number))
			{
				if (int.TryParse(number, out counter))
				{
					result = result.Remove(result.Length - number.Length);
				}
			}
			
			do
			{
				++counter;
				if (!names.Contains(result + counter))
				{
					result = result + counter;
					break;
				}
			}
			while(true);
		}
	}

	return result;
}

string ConvertToCompilableDefault(string name, bool mayRemoveUnderscore)
{
	var query =
		from c in name
		select char.IsLetterOrDigit(c) || c == '@' ? c : '_';

	return ToValidName(new string(query.ToArray()), mayRemoveUnderscore);
}

Table GetTable(string name)
{
	Table tbl;

	if (Tables.TryGetValue(name, out tbl))
		return tbl;

	WriteLine("#error Table '" + name +  "' not found.");
	WriteLine("/*");
	WriteLine("\tExisting tables:");
	WriteLine("");

	foreach (var key in Tables.Keys)
		WriteLine("\t" + key);

	WriteLine(" */");

	throw new ArgumentException("Table '" + name +  "' not found.");
}

Procedure GetProcedure(string name)
{
	Procedure proc;

	if (Procedures.TryGetValue(name, out proc))
		return proc;

	WriteLine("#error Procedure '" + name +  "' not found.");
	WriteLine("");
	WriteLine("/*");
	WriteLine("\tExisting procedures:");
	WriteLine("");

	foreach (var key in Procedures.Keys)
		WriteLine("\t" + key);

	WriteLine(" */");

	throw new ArgumentException("Procedure '" + name +  "' not found.");
}

Column GetColumn(string tableName, string columnName)
{
	var tbl = GetTable(tableName);

	Column col;

	if (tbl.Columns.TryGetValue(columnName, out col))
		return col;

	WriteLine("#error Column '" + tableName + "'.'" + columnName +  "' not found.");
	WriteLine("");
	WriteLine("/*");
	WriteLine("\tExisting '" + tableName + "'columns:");
	WriteLine("");

	foreach (var key in tbl.Columns.Keys)
		WriteLine("\t" + key);

	WriteLine(" */");

	throw new ArgumentException("Column '" + tableName + "'.'" + columnName +  "' not found.");
}

ForeignKey GetFK(string tableName, string fkName)
{
	return GetForeignKey(tableName, fkName);
}

ForeignKey GetForeignKey(string tableName, string fkName)
{
	var tbl = GetTable(tableName);

	ForeignKey col;

	if (tbl.ForeignKeys.TryGetValue(fkName, out col))
		return col;

	WriteLine("#error FK '" + tableName + "'.'" + fkName +  "' not found.");
	WriteLine("");
	WriteLine("/*");
	WriteLine("\tExisting '" + tableName + "'FKs:");
	WriteLine("");

	foreach (var key in tbl.ForeignKeys.Keys)
		WriteLine("\t" + key);

	WriteLine(" */");

	throw new ArgumentException("FK '" + tableName + "'.'" + fkName +  "' not found.");
}


public TableContext SetTable(string tableName,
	string TypeName                = null,
	string DataContextPropertyName = null)
{
	var ctx = new TableContext { Transformation = this, TableName = tableName };

	if (TypeName != null || DataContextPropertyName != null)
	{
		var t = GetTable(tableName);

		if (TypeName                != null) t.TypeName                = TypeName;
		if (DataContextPropertyName != null) t.DataContextPropertyName = DataContextPropertyName;
	}

	return ctx;
}

public class TableContext
{
	public GeneratedTextTransformation Transformation;
	public string                      TableName;

	public TableContext Column(string columnName,
		string MemberName  = null,
		string Type        = null,
		bool?  IsNullable  = null,
		string Conditional = null)
	{
		var c = Transformation.GetColumn(TableName, columnName);

		if (MemberName  != null) c.MemberName  = MemberName;
		if (Type        != null) c.Type        = Type;
		if (IsNullable  != null) c.IsNullable  = IsNullable.Value;
		if (Conditional != null) c.Conditional = Conditional;

		return this;
	}

	public TableContext FK(string fkName,
		string           MemberName      = null,
		AssociationType? AssociationType = null,
		bool?            CanBeNull       = null)
	{
		var c = Transformation.GetFK(TableName, fkName);

		if (MemberName      != null) c.MemberName      = MemberName;
		if (AssociationType != null) c.AssociationType = AssociationType.Value;
		if (CanBeNull       != null) c.CanBeNull       = CanBeNull.Value;

		return this;
	}
}


Dictionary<string,Table>     Tables     = new Dictionary<string,Table>    ();
Dictionary<string,Procedure> Procedures = new Dictionary<string,Procedure>();

public partial class Table : Class
{
	public TableSchema TableSchema             { get; set; }
	public string      Schema                  { get; set; }
	public string      TableName               { get; set; }
	public string      DataContextPropertyName { get; set; }
	public MemberBase  DataContextProperty     { get; set; }
	public bool        IsView                  { get; set; }
	public bool        IsProviderSpecific      { get; set; }
	public string      Description             { get; set; }
	public string      AliasPropertyName       { get; set; }
	public string      AliasTypeName           { get; set; }
	public string      TypePrefix              { get; set; }

	public string TypeName
	{
		get { return Name;  }
		set { Name = value; }
	}

	public Dictionary<string,Column>     Columns;
	public Dictionary<string,ForeignKey> ForeignKeys = new Dictionary<string,ForeignKey>();
}

public partial class Column : Property
{
	public string    ColumnName; // Column name in database
	public bool      IsNullable;
	public bool      IsIdentity;
	public string    ColumnType; // Type of the column in database
	public string    DataType;
	public long?     Length;
	public int?      Precision;
	public int?      Scale;
	public DbType    DbType;
	public string    Description;
	public bool      IsPrimaryKey;
	public int       PrimaryKeyOrder;
	public bool      SkipOnUpdate;
	public bool      SkipOnInsert;
	public bool      IsDuplicateOrEmpty;
	public bool      IsDiscriminator;
	public string    AliasName;

	public string MemberName
	{
		get { return Name;  }
		set { Name = value; }
	}
}

public enum AssociationType
{
	Auto,
	OneToOne,
	OneToMany,
	ManyToOne,
}

public partial class ForeignKey : Property
{
	public string       KeyName;
	public Table        OtherTable;
	public List<Column> ThisColumns;
	public List<Column> OtherColumns;
	public bool         CanBeNull;
	public ForeignKey   BackReference;

	public string MemberName
	{
		get { return Name;  }
		set { Name = value; }
	}

	private AssociationType _associationType = AssociationType.Auto;
	public  AssociationType  AssociationType
	{
		get { return _associationType; }
		set
		{
			_associationType = value;

			if (BackReference != null)
			{
				switch (value)
				{
					case AssociationType.Auto      : BackReference.AssociationType = AssociationType.Auto;      break;
					case AssociationType.OneToOne  : BackReference.AssociationType = AssociationType.OneToOne;  break;
					case AssociationType.OneToMany : BackReference.AssociationType = AssociationType.ManyToOne; break;
					case AssociationType.ManyToOne : BackReference.AssociationType = AssociationType.OneToMany; break;
				}
			}
		}
	}
}

public partial class Procedure : Method
{
	public string Schema          { get; set; }
	public string ProcedureName   { get; set; }
	public bool   IsFunction      { get; set; }
	public bool   IsTableFunction { get; set; }
	public bool   IsDefaultSchema { get; set; }
	public bool   IsLoaded        { get; set; }

	public Table           ResultTable     { get; set; }
	public Exception       ResultException { get; set; }
	public List<Table>     SimilarTables   { get; set; }
	public List<Parameter> ProcParameters  { get; set; }
}

public class Parameter
{
	public string   SchemaName    { get; set; }
	public string   SchemaType    { get; set; }
	public bool     IsIn          { get; set; }
	public bool     IsOut         { get; set; }
	public bool     IsResult      { get; set; }
	public long?    Size          { get; set; }

	public string   ParameterName { get; set; }
	public string   ParameterType { get; set; }
	public Type     SystemType    { get; set; }
	public string   DataType      { get; set; }
}

private int _counter = 0;

string ToValidNameDefault(string name, bool mayRemoveUnderscore)
{
	if (NormalizeNames && mayRemoveUnderscore && name.Contains("_"))
	{
		name = SplitAndJoin(name, "", '_');
	}	

	if (name.Contains("."))
	{
		name = SplitAndJoin(name, "", '.');
	}
		
	if (name.Length > 0 && char.IsDigit(name[0]))
		name = "_" + name;

	if (string.IsNullOrEmpty(name))
		name = "_" + _counter++;

	if (NormalizeNames)
	{
		name = char.ToUpper(name[0]) + name.Substring(1);
	}

	return name;
}

static string SplitAndJoin(string value, string join, params char[] split)
{
	var ss = value.Split(split, StringSplitOptions.RemoveEmptyEntries)
		.Select(s => char.ToUpper(s[0]) + s.Substring(1));

	return string.Join(join, ss.ToArray());
}

private string GetAssociationExtensionSinglularNameDefault(ForeignKey key)
{
	return ToSingular(key.Name);
}

private string GetAssociationExtensionPluralNameDefault(ForeignKey key)
{
	return ToPlural(ToSingular(key.Name));
}

#>