sharedutils.atcs

.net samples

<#--
	Shared CSharp static methods.
--##>
<#@ Imports
using System;
using System.Data;
using System.Data.OleDb;

using TwoLKit.nTierBuilder.Api.DbDom;
##>
<#@ InstanceMembers
	public override bool Enabled
	{
		get { return false; }
	}

	public override string RelativeFilePath
	{
		get { return null; }
	}
	
	// Static methods

	static internal bool GetGenerateMSSqlStoredProcedures(IDatabase database)
	{
		return Convert.ToBoolean(database.ExtendedProperties["GenerateMSSqlStoredProcedures"]);
	}

	static internal string GetDbTierNamespace(IDatabase database)
	{
		return database.ExtendedProperties["DbTierNamespace"];
	}

	static internal string GetFieldName(string codeName)
	{
		return "_" + GetParameterName(codeName);
	}

	static internal string GetParameterName(string codeName)
	{
		return Char.ToLower(codeName[0]) + codeName.Substring(1);
	}

	static internal string GetPropertyName(string codeName)
	{
		return Char.ToUpper(codeName[0]) + codeName.Substring(1);
	}
	
	static internal IColumn GetIdentityColumn(ITable table)
	{
		foreach(IColumn column in table.Columns)
		{
			if(IsIdentity(column))
				return column;
		}
		return null;
	}

	static private bool IsIdentity(IColumn column)
	{
		return column.ReadOnly && (column.OleDbType == OleDbType.BigInt || 
			column.OleDbType == OleDbType.Decimal || 
			column.OleDbType == OleDbType.Double || 
			column.OleDbType == OleDbType.Integer || 
			column.OleDbType == OleDbType.Numeric || 
			column.OleDbType == OleDbType.Single || 
			column.OleDbType == OleDbType.SmallInt || 
			column.OleDbType == OleDbType.TinyInt || 
			column.OleDbType == OleDbType.UnsignedBigInt || 
			column.OleDbType == OleDbType.UnsignedInt || 
			column.OleDbType == OleDbType.UnsignedSmallInt || 
			column.OleDbType == OleDbType.UnsignedTinyInt || 
			column.OleDbType == OleDbType.VarNumeric);
	}

	internal static Type ToDotNetType(OleDbType oleDbType)
	{
		switch(oleDbType)
		{
			case OleDbType.BigInt:
				return typeof(long);

			case OleDbType.Binary:
				return typeof(byte[]);

			case OleDbType.Boolean:
				return typeof(bool);

			case OleDbType.BSTR:
				return typeof(string);

			case OleDbType.Char:
				return typeof(string);

			case OleDbType.Currency:
				return typeof(decimal);

			case OleDbType.Date:
				return typeof(DateTime);

			case OleDbType.DBDate:
				return typeof(DateTime);

			case OleDbType.DBTime:
				return typeof(TimeSpan);

			case OleDbType.DBTimeStamp:
				return typeof(DateTime);

			case OleDbType.Decimal:
				return typeof(decimal);

			case OleDbType.Double:
				return typeof(double);

				//case OleDbType.Empty:
				//	return typeof(Empty);

			case OleDbType.Error:
				return typeof(Exception);

			case OleDbType.Filetime:
				return typeof(DateTime);

			case OleDbType.Guid:
				return typeof(Guid);

			case OleDbType.IDispatch:
				return typeof(object);

			case OleDbType.Integer:
				return typeof(int);

			case OleDbType.IUnknown:
				return typeof(object);

			case OleDbType.LongVarBinary:
				return typeof(byte[]);

			case OleDbType.LongVarChar:
				return typeof(string);

			case OleDbType.LongVarWChar:
				return typeof(string);

			case OleDbType.Numeric:
				return typeof(decimal);

			case OleDbType.PropVariant:
				return typeof(object);

			case OleDbType.Single:
				return typeof(float);

			case OleDbType.SmallInt:
				return typeof(short);

			case OleDbType.TinyInt:
				return typeof(sbyte);

			case OleDbType.UnsignedBigInt:
				return typeof(ulong);

			case OleDbType.UnsignedInt:
				return typeof(uint);

			case OleDbType.UnsignedSmallInt:
				return typeof(ushort);

			case OleDbType.UnsignedTinyInt:
				return typeof(byte);

			case OleDbType.VarBinary:
				return typeof(byte[]);

			case OleDbType.VarChar:
				return typeof(string);

			case OleDbType.Variant:
				return typeof(object);

			case OleDbType.VarNumeric:
				return typeof(decimal);

			case OleDbType.VarWChar:
				return typeof(string);

			case OleDbType.WChar:
				return typeof(string);

			default:
				throw new ArgumentException("Unknown OleDbType " + oleDbType);
		}
	}

	static internal Type GetDotNetType(IColumn column, bool convertNullableValueTypes)
	{
		Type dotNetType = ToDotNetType(column.OleDbType);
		if(convertNullableValueTypes && column.Nullable && dotNetType.IsValueType)
			dotNetType = typeof(object);
		return dotNetType;
	}

	static internal string GetCSharpTypeName(Type type) 
	{
		string typeName = type.FullName;

		string arraySuffix = null;
		int arraySignIndex = typeName.IndexOf('[');
		if(-1 != arraySignIndex)
		{
			arraySuffix = typeName.Substring(arraySignIndex).Replace("[]", "()");
			typeName = typeName.Substring(0, arraySignIndex);
		}

		switch(typeName)
		{
			case "System.Object":
				typeName = "Object";
				break;

			case "System.String":
				typeName = "String";
				break;

			case "System.Boolean":
				typeName = "Boolean";
				break;

			case "System.Int32":
				typeName = "Integer";
				break;

			case "System.Int16":
				typeName = "Short";
				break;

			case "System.Int64":
				typeName = "Long";
				break;

			case "System.Byte":
				typeName = "Byte";
				break;

			case "System.Decimal":
				typeName = "Decimal";
				break;

			case "System.Single":
				typeName = "Single";
				break;

			case "System.Double":
				typeName = "Double";
				break;

			case "System.Char":
				typeName = "Char";
				break;
				
			case "System.DateTime":
				typeName = "Date";
				break;

			default:
				return type.FullName;
		}

		return null == arraySuffix ? typeName : typeName + arraySuffix;
	}

	internal static string GetMSSqlParameterType(IColumn column)
	{
		switch(column.DbType)
		{
			case DbType.AnsiString:
			case DbType.AnsiStringFixedLength:
				if(column.Long)
					return "Text";
				if(column.FixedLength)
					return "Char(" + column.Length + ')';
				return "VarChar(" + column.Length + ')';
				
			case DbType.Binary:
				if(column.RowVer)
					return "TimeStamp";
				if(column.Long)
					return "Image";
				if(column.FixedLength)
					return "Binary(" + column.Length + ')';
				return "VarBinary(" + column.Length + ')';
				break;
				
			case DbType.Boolean:
				return "Bit";
				
			case DbType.Byte:
				return "TinyInt";
			
			case DbType.Currency:
				if(10 >= column.Precision)
					return "SmallMoney";
				return "Money";
			
			case DbType.Date:
				return "MS SQL DOES NOT SUPPORT DbType.Date";
				
			case DbType.DateTime:
				if(0 == column.Precision)
					return "SmallDateTime";
				return "DateTime";
				
			case DbType.Decimal:
				return "Decimal(" + column.Precision + ", " + column.Scale + ")";
				
			case DbType.Double:
				return "Float(" + column.Precision + ")";
				
			case DbType.Guid:
				return "UniqueIdentifier";
				
			case DbType.Int16:
				return "SmallInt";

			case DbType.Int32:
				return "Int";
				
			case DbType.Int64:
				return "BigInt";
				
			case DbType.Object:
				return "SQL_Variant";
				
			case DbType.SByte:
				return "MS SQL DOES NOT SUPPORT DbType.SByte";
				
			case DbType.Single:
				return "Real";
				
			case DbType.String:
			case DbType.StringFixedLength:
				if(column.Long)
					return "NText";
				if(column.FixedLength)
					return "NChar(" + column.Length + ')';
				return "NVarChar(" + column.Length + ')';
				
			case DbType.Time:
				return "MS SQL DOES NOT SUPPORT DbType.Time";
				
			case DbType.UInt16:
				return "MS SQL DOES NOT SUPPORT DbType.UInt16";

			case DbType.UInt32:
				return "MS SQL DOES NOT SUPPORT DbType.UInt32";

			case DbType.UInt64:
				return "MS SQL DOES NOT SUPPORT DbType.UInt64";
				
			case DbType.VarNumeric:
				return "MS SQL DOES NOT SUPPORT DbType.VarNumeric";
		}
		return "UNKNOWN DBType " + column.DbType;
	}

	internal static string GetReaderMethodName(IColumn column)
	{
		switch(column.OleDbType)
		{
			case OleDbType.BigInt:
				return "GetInt64";

			case OleDbType.Binary:
				return "GetValue";

			case OleDbType.Boolean:
				return "GetBoolean";

			case OleDbType.BSTR:
				return "GetString";

			case OleDbType.Char:
				return "GetString";

			case OleDbType.Currency:
				return "GetDecimal";

			case OleDbType.Date:
				return "GetDateTime";

			case OleDbType.DBDate:
				return "GetDateTime";

			case OleDbType.DBTime:
				return "GetTimeSpan";

			case OleDbType.DBTimeStamp:
				return "GetDateTime";

			case OleDbType.Decimal:
				return "GetDecimal";

			case OleDbType.Double:
				return "GetDouble";

				//case OleDbType.Empty:
				//	return typeof(Empty);

			case OleDbType.Error:
				return "TODO";	//typeof(Exception);

			case OleDbType.Filetime:
				return "GetDateTime";

			case OleDbType.Guid:
				return "GetGuid";

			case OleDbType.IDispatch:
				return "GetValue";

			case OleDbType.Integer:
				return "GetInt32";

			case OleDbType.IUnknown:
				return "GetValue";

			case OleDbType.LongVarBinary:
				return "GetValue";	//typeof(byte[]);

			case OleDbType.LongVarChar:
				return "GetString";

			case OleDbType.LongVarWChar:
				return "GetString";

			case OleDbType.Numeric:
				return "GetDecimal";

			case OleDbType.PropVariant:
				return "GetValue";

			case OleDbType.Single:
				return "GetFloat";

			case OleDbType.SmallInt:
				return "GetInt16";

			case OleDbType.TinyInt:
				return "TODO";	// sbyte

			case OleDbType.UnsignedBigInt:
				return "TODO";	//typeof(ulong);

			case OleDbType.UnsignedInt:
				return "TODO";	//typeof(uint);

			case OleDbType.UnsignedSmallInt:
				return "TODO";	//typeof(ushort);

			case OleDbType.UnsignedTinyInt:
				return "GetByte";

			case OleDbType.VarBinary:
				return "GetValue";	//typeof(byte[]);

			case OleDbType.VarChar:
				return "GetString";

			case OleDbType.Variant:
				return "GetValue";

			case OleDbType.VarNumeric:
				return "GetDecimal";

			case OleDbType.VarWChar:
				return "GetString";

			case OleDbType.WChar:
				return "GetString";

			default:
				throw new Exception("Unknown OleDbType " + column.OleDbType);
		}
	}
#>