private static string GetVariableType(DbType dbType)
		{
			switch (dbType) {
				case DbType.AnsiString:
				case DbType.AnsiStringFixedLength:
				case DbType.String:
				case DbType.StringFixedLength: return "string";

				case DbType.Binary:		return "byte[]";
				case DbType.Boolean:	return "bool";
				case DbType.Byte:		return "byte";

				case DbType.Currency:
				case DbType.Decimal:
				case DbType.VarNumeric:	return "decimal";

				case DbType.Date:
				case DbType.DateTime:	return "DateTime";

				case DbType.Double:		return "double";
				case DbType.Guid:		return "Guid";
				case DbType.Int16:		return "short";
				case DbType.Int32:		return "int";
				case DbType.Int64:		return "long";
				case DbType.Object:		return "object";
				case DbType.SByte:		return "sbyte";
				case DbType.Single:		return "float";
				case DbType.Time:		return "TimeSpan";
				case DbType.UInt16:		return "ushort";
				case DbType.UInt32:		return "uint";
				case DbType.UInt64:		return "ulong";

				default:				return "string";
			}
		}

 public static bool ContainsRule(Csla.Core.BusinessBase obj, DbType type, string propertyName)
 {
     switch (type)
     {
         case DbType.Int16:
         case DbType.Int32:
         case DbType.Int64:
             return obj.BrokenRulesCollection.Any(
                  brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.integerrequired/{0}", propertyName))
                     || obj.BrokenRulesCollection.Any(
                         brokenRule => brokenRule.RuleName == string.Format("rule://csla.rules.commonrules.dataannotation/{0}?a=Epiworx.Core.Validation.IntegerRequiredAttribute", propertyName));
         case DbType.Decimal:
             return obj.BrokenRulesCollection.Any(
                 brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.decimalrequired/{0}", propertyName));
         case DbType.Date:
             return obj.BrokenRulesCollection.Any(
               brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.daterequired/{0}", propertyName));
         case DbType.DateTime:
             return obj.BrokenRulesCollection.Any(
               brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.datetimerequired/{0}", propertyName));
         case DbType.String:
         case DbType.StringFixedLength:
             return obj.BrokenRulesCollection.Any(
              brokenRule => brokenRule.RuleName == string.Format("rule://epiworx.core.validation.stringrequired/{0}", propertyName));
         default:
             throw new NotSupportedException();
     }
 }

 protected CouchBase(string username, string password, AuthenticationType aT, DbType dbType)
 {
     this.username = username;
     this.password = password;
     this.authType = aT;
     this.dbType = dbType;
 }

 /// <summary>
 /// Constructs a VarArgsSQLFunction instance with a 'static' return type.  An example of a 'static'
 /// return type would be something like an <code>UPPER</code> function which is always returning
 /// a SQL VARCHAR and thus a string type.
 /// </summary>
 /// <param name="registeredType">the return type</param>
 /// <param name="begin">the beginning of the function templating</param>
 /// <param name="sep">the separator for each individual function argument</param>
 /// <param name="end">the end of the function templating</param>
 public VarArgsSQLFunction(DbType registeredType, String begin, String sep, String end)
 {
     this.registeredType = registeredType;
     this.begin = begin;
     this.sep = sep;
     this.end = end;
 }

        protected override string TypeName(DbType type) {
            switch (type) {
                case DbType.Binary:
                    return "bit";

                case DbType.Boolean:
                    return "smallint unsigned";

                case DbType.Byte:
                    return "smallint unsigned";

                case DbType.DateTime:
                case DbType.DateTime2:
                    return "timestamp";

                case DbType.DateTimeOffset:
                    return "timestamptz";

                case DbType.Double:
                    return "double precision";

                default:
                    return base.TypeName(type);
            }
        }

 public Parameters(string Name, object Value,DbType dbType)
 {
     ParamName = Name;
     ParamValue = Value;
     ParamDbType = dbType;
     ParamDirection = ParameterDirection.Input;
 }

 public DBMapping(string first, string second, DbType type, int size)
 {
     this._first = first;
     this._second = second;
     this._type = type;
     this._size = size;
 }

 public static void CreateParameter(this IDbCommand command, string name, DbType dbType)
 {
   IDbDataParameter parameter = command.CreateParameter();
   parameter.ParameterName = name;
   parameter.DbType = dbType;
   command.Parameters.Add(parameter);
 }

        public RelationalTypeMapping([NotNull] string defaultTypeName, DbType? storeType = null)
        {
            Check.NotEmpty(defaultTypeName, nameof(defaultTypeName));

            DefaultTypeName = defaultTypeName;
            StoreType = storeType;
        }

 /// <summary>
 /// Extension for adding single parameter
 /// </summary>
 public static void AddParam(this DbCommand cmd, object item, DbType? type = null)
 {
     var p = cmd.CreateParameter();
     p.ParameterName = string.Format("@{0}", cmd.Parameters.Count);
     if (item == null)
     {
         p.Value = DBNull.Value;
     }
     else
     {
         if (item.GetType() == typeof(Guid))
         {
             p.Value = item.ToString();
             p.DbType = DbType.String;
             p.Size = 4000;
         }
         else if (item.GetType() == typeof(ExpandoObject))
         {
             var d = (IDictionary<string, object>)item;
             p.Value = d.Values.FirstOrDefault();
         }
         else
         {
             p.Value = item;
             if (type.HasValue)
                 p.DbType = type.Value;
         }
         if (item.GetType() == typeof(string))
             p.Size = ((string)item).Length > 4000 ? -1 : 4000;
     }
     cmd.Parameters.Add(p);
 }

 public Column(string name, DbType type)
 {
     ColumnName = name;
     IsAutoIncrement = false;
     Type = type;
     IsNullable = true;
 }

        protected override IDataParameter GetParameter(string name, object paramValue, DbType datatype)
        {
            object value = paramValue;
            DbType localDatatype = datatype;
            if (datatype == DbType.Guid)
                localDatatype = DbType.String;
            else
                localDatatype = datatype;

            NpgsqlParameter param;
            if (datatype == DbType.Guid && value != DBNull.Value)
            {
                value = new Guid(paramValue.ToString());
                param = new NpgsqlParameter(name, localDatatype);
                param.Value = value;
            }
            else
            {
                param = new NpgsqlParameter(name, value);
                param.DbType = localDatatype;

            }

            return param;
        }

 public ExtendedProperty(string name, object value, DbType dataType, PropertyStateEnum state)
 {
     this.name = name;
     this.value = value;
     this.dataType = dataType;
     this.propertyState = state;
 }

 public static void AreEqual(string parameterName, object value, DbType dbType, SqlParameter actual)
 {
     Assert.IsNotNull(actual, "Parameter should not be null.");
     Assert.AreEqual(parameterName, actual.ParameterName, "ParameterName");
     Assert.AreEqual(value, actual.Value, "Value");
     Assert.AreEqual(dbType, actual.DbType, "DbType");
 }

 internal static void TryDetermineSubQueryDataType(SelectStatement query, out Type dataType, out DbType dbType)
 {
     // Automatically determine data type if possible.
     if (query.SelectList.Count == 1)
     {
         SelectItem firstItem = query.SelectList[0];
         if (firstItem.ItemType == SqlItemType.Column)
         {
             IDbColumn field = (IDbColumn)firstItem.Item;
             dataType = field.DataType;
             dbType = field.DbType;
         }
         else if (firstItem.ItemType == SqlItemType.Function)
         {
             Function function = (Function)firstItem.Item;
             dataType = function.DataType;
             dbType = function.DbType;
         }
         else
         {
             dataType = typeof(object);
             dbType = DbType.Object;
         }
     }
     else
     {
         dataType = typeof(object);
         dbType = DbType.Object;
     }
 }

		public DbParameter CreateParameter(Type connectionType, string sourceColumn, ParameterDirection parameterDirection, DbType parameterDbType, int parameterSize, byte parameterPrecision, byte parameterScale, bool parameterNullable, string parameterName, object parameterValue)
		{
			DbParameter dbParameter;

			if ((object)connectionType == null)
				throw new ArgumentNullException(nameof(connectionType));

			using (DbConnection dbConnection = (DbConnection)Activator.CreateInstance(connectionType))
			{
				using (DbCommand dbCommand = dbConnection.CreateCommand())
					dbParameter = dbCommand.CreateParameter();

				dbParameter.ParameterName = parameterName;
				dbParameter.Size = parameterSize;
				dbParameter.Value = parameterValue;
				dbParameter.Direction = parameterDirection;
				dbParameter.DbType = parameterDbType;
				this.ReflectionFascade.SetLogicalPropertyValue(dbParameter, "IsNullable", parameterNullable, true, false);
				dbParameter.Precision = parameterPrecision;
				dbParameter.Scale = parameterScale;
				dbParameter.SourceColumn = sourceColumn;

				return dbParameter;
			}
		}

 public void CreateAndCacheDbCommandParameters(string sqlCommandText,
                                               DbCommand command,
                                               string[] paramNames,
                                               DbType[] paramDbTypes,
                                               object[] paramValues) 
 {
     lock (lockObject)
     {
         if (this.ParameterCache.IsCache(sqlCommandText))
         {
             this.ParameterCache.AddParametersFromCache(sqlCommandText, command, paramDbTypes, paramValues);
         }
         else
         {
             if (this.ParameterCache.IsCache(sqlCommandText))
             {
                 this.ParameterCache.AddParametersFromCache(sqlCommandText, command, paramDbTypes, paramValues);
             }
             else
             {
                 this.ParameterCache.CreateAndCacheParameters(sqlCommandText, command, paramNames, paramDbTypes, paramValues);
             }
         }
     }
 }

 public void Add(string name, DbType type)
 {
     DbParameter parameter = Command.CreateParameter();
     parameter.ParameterName = string.Format("{0}{1}", ParameterPrefix, name);
     parameter.DbType = type;
     Command.Parameters.Add(parameter);
 }

 public EntityParameter(string parameterName, DbType dbType, int size, string sourceColumn)
 {
     SetParameterNameWithValidation(parameterName, "parameterName");
     DbType = dbType;
     Size = size;
     SourceColumn = sourceColumn;
 }

 public DbParameterHelper(DbType type, string name, object value, ParameterDirection direction)
 {
     DbType = type;
     Name = name;
     Value = value;
     Direction = direction;
 }