970 lines
34 KiB
C#
970 lines
34 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace MJTop.Data
|
|
{
|
|
/// <summary>
|
|
/// 全局静态字典
|
|
/// </summary>
|
|
public class Global
|
|
{
|
|
/// <summary>
|
|
/// Type类型对应的DbType类型 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<Type, DbType> TypeMap = new Dictionary<Type, DbType>
|
|
{
|
|
[typeof(byte)] = DbType.Byte,
|
|
[typeof(sbyte)] = DbType.SByte,
|
|
[typeof(short)] = DbType.Int16,
|
|
[typeof(ushort)] = DbType.UInt16,
|
|
[typeof(int)] = DbType.Int32,
|
|
[typeof(uint)] = DbType.UInt32,
|
|
[typeof(long)] = DbType.Int64,
|
|
[typeof(ulong)] = DbType.UInt64,
|
|
[typeof(float)] = DbType.Single,
|
|
[typeof(double)] = DbType.Decimal,
|
|
[typeof(decimal)] = DbType.Decimal,
|
|
[typeof(bool)] = DbType.Boolean,
|
|
[typeof(string)] = DbType.String,
|
|
[typeof(char)] = DbType.StringFixedLength,
|
|
[typeof(Guid)] = DbType.Guid,
|
|
[typeof(DateTime)] = DbType.DateTime,
|
|
[typeof(DateTimeOffset)] = DbType.DateTimeOffset,
|
|
[typeof(TimeSpan)] = DbType.Time,
|
|
[typeof(byte[])] = DbType.Binary,
|
|
[typeof(byte?)] = DbType.Byte,
|
|
[typeof(sbyte?)] = DbType.SByte,
|
|
[typeof(short?)] = DbType.Int16,
|
|
[typeof(ushort?)] = DbType.UInt16,
|
|
[typeof(int?)] = DbType.Int32,
|
|
[typeof(uint?)] = DbType.UInt32,
|
|
[typeof(long?)] = DbType.Int64,
|
|
[typeof(ulong?)] = DbType.UInt64,
|
|
[typeof(float?)] = DbType.Single,
|
|
[typeof(double?)] = DbType.Decimal,
|
|
[typeof(decimal?)] = DbType.Decimal,
|
|
[typeof(bool?)] = DbType.Boolean,
|
|
[typeof(char?)] = DbType.StringFixedLength,
|
|
[typeof(Guid?)] = DbType.Guid,
|
|
[typeof(DateTime?)] = DbType.DateTime,
|
|
[typeof(DateTimeOffset?)] = DbType.DateTimeOffset,
|
|
[typeof(TimeSpan?)] = DbType.Time,
|
|
[typeof(object)] = DbType.Object
|
|
};
|
|
|
|
/// <summary>
|
|
/// 不同数据库 参数化 时所使用的字符
|
|
/// </summary>
|
|
public readonly static Dictionary<DBType, string> ParameterCharMap = new Dictionary<DBType, string>
|
|
{
|
|
{ DBType.SqlServer,"@" },
|
|
{ DBType.MySql,"@" },
|
|
{ DBType.Oracle,":" },
|
|
{ DBType.PostgreSql,":" },
|
|
{ DBType.SQLite,"@" },
|
|
{ DBType.DB2,":" },
|
|
};
|
|
|
|
|
|
#region 各种数据库
|
|
/// <summary>
|
|
/// SqlServer的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_SqlServer_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "bigint",DbType.Int64 },
|
|
{ "binary",DbType.Binary },
|
|
{ "bit",DbType.Boolean },
|
|
{ "char",DbType.AnsiStringFixedLength },
|
|
{ "date",DbType.Date },
|
|
{ "datetime",DbType.DateTime },
|
|
{ "datetime2",DbType.DateTime2 },
|
|
{ "datetimeoffset",DbType.DateTimeOffset },
|
|
{ "decimal",DbType.Decimal },
|
|
{ "float",DbType.Single },
|
|
{ "geography",DbType.Object },
|
|
{ "geometry",DbType.Object },
|
|
{ "hierarchyid",DbType.Object },
|
|
{ "image",DbType.Binary },
|
|
{ "int",DbType.Int32 },
|
|
{ "money",DbType.Currency },
|
|
{ "nchar",DbType.StringFixedLength },
|
|
{ "ntext",DbType.String },
|
|
{ "numeric",DbType.Decimal },
|
|
{ "nvarchar",DbType.StringFixedLength },
|
|
{ "real",DbType.Decimal },
|
|
{ "smalldatetime",DbType.DateTime },
|
|
{ "smallint",DbType.Int16 },
|
|
{ "smallmoney",DbType.Currency },
|
|
{ "sql_variant",DbType.Object },
|
|
//{ "sysname",DbType.AnsiString },
|
|
{ "text",DbType.AnsiString },
|
|
{ "time",DbType.Time },
|
|
{ "timestamp",DbType.Binary },
|
|
{ "tinyint",DbType.Byte },
|
|
{ "uniqueidentifier",DbType.Guid },
|
|
{ "varbinary",DbType.Binary },
|
|
{ "varchar",DbType.AnsiStringFixedLength },
|
|
{ "xml",DbType.Xml }
|
|
};
|
|
|
|
/// <summary>
|
|
/// SqlServer的 数据类型对应CSharpType 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_SqlServer_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "bigint","long" },
|
|
{ "binary","byte[]" },
|
|
{ "bit","bool" },
|
|
{ "char","string" },
|
|
{ "date","DateTime" },
|
|
{ "datetime","DateTime" },
|
|
{ "datetime2","DateTime" },
|
|
{ "datetimeoffset","DateTimeOffset" },
|
|
{ "decimal","decimal" },
|
|
{ "float","float" },
|
|
{ "geography","object" },
|
|
{ "geometry","object" },
|
|
{ "hierarchyid","object" },
|
|
{ "image","byte[]" },
|
|
{ "int","int" },
|
|
{ "money","decimal" },
|
|
{ "nchar","string" },
|
|
{ "ntext","string" },
|
|
{ "numeric","decimal" },
|
|
{ "nvarchar","string" },
|
|
{ "real","decimal" },
|
|
{ "smalldatetime","DateTime" },
|
|
{ "smallint","int"},
|
|
{ "smallmoney","decimal" },
|
|
{ "sql_variant","object" },
|
|
//{ "sysname",DbType.AnsiString },
|
|
{ "text","string" },
|
|
{ "time","string" },
|
|
{ "timestamp","byte[]" },
|
|
{ "tinyint","int" },
|
|
{ "uniqueidentifier","Guid" },
|
|
{ "varbinary","byte[]" },
|
|
{ "varchar","string" },
|
|
{ "xml","string"}
|
|
};
|
|
|
|
/// <summary>
|
|
/// SqlServer的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_SqlServer_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
{ "getdate","DateTime.Now" },
|
|
{ "newid","Guid.NewGuid()" }
|
|
};
|
|
|
|
|
|
/// <summary>
|
|
/// Oracle的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_Oracle_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "BOOLEAN",DbType.Boolean },
|
|
|
|
{ "CHAR",DbType.AnsiStringFixedLength },
|
|
{ "VARCHAR2",DbType.AnsiStringFixedLength },
|
|
{ "NCHAR",DbType.StringFixedLength },
|
|
{ "NVARCHAR2",DbType.StringFixedLength },
|
|
|
|
{ "DATE",DbType.DateTime },
|
|
{ "TIMESTAMP",DbType.DateTime },
|
|
|
|
{ "LONG",DbType.AnsiString },//用于存储可变长度字符串。
|
|
{ "RAW",DbType.Binary },//此数据类型用于存储二进制数据或字符串。字符变量是由Oracle在字符集之间自动转换的。
|
|
{ "LONG RAW",DbType.Binary },//此数据类型用户存储二进制数据或字符串。与RAW不同之处是它不在字符集之间进行转换。
|
|
|
|
{ "BLOB",DbType.Binary },//将大型二进制对象存储在数据库中
|
|
{ "CLOB",DbType.AnsiString },//将大型字符数据存储在数据库中
|
|
{ "NCLOB",DbType.String },//存储大型UNICODE字符数据
|
|
{ "BFILE",DbType.Binary },//将大型二进制对象存储在操作系统文件中
|
|
|
|
{ "ROWID",DbType.AnsiString },
|
|
{ "NROWID",DbType.String },
|
|
|
|
{ "NUMBER",DbType.Decimal },
|
|
{ "DECIMAL",DbType.Decimal },
|
|
{ "INTEGER",DbType.Int32 },
|
|
{ "FLOAT",DbType.Decimal },
|
|
{ "REAL",DbType.Decimal }
|
|
};
|
|
|
|
/// <summary>
|
|
/// Oracle的 数据类型对应CSharpType 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_Oracle_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "BOOLEAN","bool"},
|
|
{ "CHAR","string" },
|
|
{ "VARCHAR2","string" },
|
|
{ "NCHAR","string" },
|
|
{ "NVARCHAR2","string" },
|
|
|
|
{ "DATE","DateTime" },
|
|
{ "TIMESTAMP","DateTime"},
|
|
|
|
{ "LONG","string" },//用于存储可变长度字符串。
|
|
{ "RAW","byte[]" },//此数据类型用于存储二进制数据或字符串。字符变量是由Oracle在字符集之间自动转换的。
|
|
{ "LONG RAW","byte[]" },//此数据类型用户存储二进制数据或字符串。与RAW不同之处是它不在字符集之间进行转换。
|
|
|
|
{ "BLOB","byte[]"},//将大型二进制对象存储在数据库中
|
|
{ "CLOB","string" },//将大型字符数据存储在数据库中
|
|
{ "NCLOB","string" },//存储大型UNICODE字符数据
|
|
{ "BFILE","byte[]" },//将大型二进制对象存储在操作系统文件中
|
|
|
|
{ "ROWID","string" },
|
|
{ "NROWID","string" },
|
|
|
|
{ "NUMBER","decimal"},
|
|
{ "DECIMAL","decimal" },
|
|
{ "INTEGER","int" },
|
|
{ "FLOAT","float" },
|
|
{ "REAL","decimal" }
|
|
};
|
|
|
|
/// <summary>
|
|
/// Oracle的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_Oracle_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// MySql的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_MySql_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "bit",DbType.Boolean },
|
|
{ "bool",DbType.Boolean },
|
|
{ "boolean",DbType.Boolean },
|
|
|
|
{ "tinyint",DbType.SByte },
|
|
{ "smallint",DbType.Int16 },
|
|
{ "mediumint",DbType.Int32 },
|
|
{ "int",DbType.Int32 },
|
|
{ "integer",DbType.Int32 },
|
|
{ "bigint",DbType.Int64 },
|
|
|
|
{ "enum",DbType.Int32 },
|
|
{ "set",DbType.Int32 },
|
|
|
|
{ "binary",DbType.Binary },
|
|
{ "varbinary",DbType.Binary },
|
|
{ "tinyblob",DbType.Binary },
|
|
{ "mediumblob",DbType.Binary },
|
|
{ "blob",DbType.Binary },
|
|
{ "longblob",DbType.Binary },
|
|
|
|
{ "date",DbType.DateTime },
|
|
{ "year",DbType.Int32 },
|
|
{ "time",DbType.Time },
|
|
{ "datetime",DbType.DateTime },
|
|
{ "timestamp",DbType.DateTime },
|
|
|
|
{ "decimal",DbType.Decimal },
|
|
{ "dec",DbType.Decimal },
|
|
{ "double",DbType.Decimal },
|
|
{ "float",DbType.Single },
|
|
{ "real",DbType.Single },
|
|
|
|
{ "char",DbType.AnsiStringFixedLength },
|
|
{ "varchar",DbType.AnsiStringFixedLength },
|
|
{ "nchar",DbType.StringFixedLength },
|
|
{ "nvarchar",DbType.StringFixedLength },
|
|
{ "tinytext",DbType.String },
|
|
{ "text",DbType.String },
|
|
{ "mediumtext",DbType.String },
|
|
{ "longtext",DbType.String }
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// MySql的 数据类型对应CSharpType 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_MySql_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "bit","bool" },
|
|
{ "bool","bool" },
|
|
{ "boolean","bool" },
|
|
|
|
{ "tinyint","int" },
|
|
{ "smallint","int" },
|
|
{ "mediumint","int" },
|
|
{ "int","int" },
|
|
{ "integer","int" },
|
|
{ "bigint","long" },
|
|
|
|
{ "enum","int" },
|
|
{ "set","int"},
|
|
|
|
{ "binary","byte[]" },
|
|
{ "varbinary","byte[]" },
|
|
{ "tinyblob","byte[]" },
|
|
{ "mediumblob","byte[]" },
|
|
{ "blob","byte[]" },
|
|
{ "longblob","byte[]" },
|
|
|
|
{ "date","DateTime" },
|
|
{ "year","int" },
|
|
{ "time","string"},
|
|
{ "datetime","DateTime" },
|
|
{ "timestamp","DateTime"},
|
|
|
|
{ "decimal","decimal" },
|
|
{ "dec","decimal" },
|
|
{ "double","double" },
|
|
{ "float","float"},
|
|
{ "real","decimal" },
|
|
|
|
{ "char","string" },
|
|
{ "varchar","string" },
|
|
{ "nchar","string" },
|
|
{ "nvarchar","string" },
|
|
{ "tinytext","string" },
|
|
{ "text","string" },
|
|
{ "mediumtext","string" },
|
|
{ "longtext","string" }
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// MySql的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_MySql_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
{"CURRENT_TIMESTAMP","DateTime.Now" },
|
|
{"CURRENT_TIMESTAMP(6)","DateTime.Now" }
|
|
};
|
|
|
|
|
|
/// <summary>
|
|
/// PostgreSQL的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_PostgreSql_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "smallint",DbType.Int16 },
|
|
{ "integer",DbType.Int32 },
|
|
{ "bigint",DbType.Int64 },
|
|
{ "decimal",DbType.Decimal },
|
|
{ "numeric",DbType.Decimal },
|
|
{ "real",DbType.Int32 },
|
|
{ "double precision",DbType.Decimal },
|
|
{ "smallserial",DbType.Int16 },
|
|
{ "serial",DbType.Int32 },
|
|
{ "bigserial",DbType.Int64 },
|
|
|
|
{ "money",DbType.Decimal },
|
|
|
|
{ "character varying",DbType.StringFixedLength },
|
|
{ "character",DbType.StringFixedLength },
|
|
{ "text",DbType.StringFixedLength },
|
|
|
|
{ "bytea",DbType.Binary },
|
|
|
|
{ "timestamp",DbType.DateTime },
|
|
{ "date",DbType.DateTime },
|
|
{ "time",DbType.Time },
|
|
{ "interval",DbType.Int32 },
|
|
|
|
{ "boolean",DbType.Boolean },
|
|
|
|
{ "enum",DbType.String },
|
|
|
|
{ "point",DbType.Object},
|
|
{ "line",DbType.Object},
|
|
{ "lseg",DbType.Object},
|
|
{ "box",DbType.Object},
|
|
{ "path",DbType.Object},
|
|
{ "polygon",DbType.Object},
|
|
{ "circle",DbType.Object},
|
|
|
|
{ "cidr",DbType.String},//IPv4和IPv6网络
|
|
{ "inet",DbType.String},//IPv4和IPv6主机以及网络
|
|
{ "macaddr",DbType.String},//MAC地址
|
|
|
|
{ "bit",DbType.Boolean},
|
|
{ "bit varying",DbType.String},
|
|
|
|
{ "tsvector",DbType.String},
|
|
{ "tsquery",DbType.String},
|
|
|
|
{ "UUID",DbType.Guid},
|
|
|
|
{ "Xml",DbType.Xml},
|
|
|
|
{ "json",DbType.String},
|
|
{ "jsonb",DbType.String},
|
|
|
|
{ "int4range",DbType.String},
|
|
{ "int8range",DbType.String},
|
|
{ "numrange",DbType.String},
|
|
{ "tsrange",DbType.String},
|
|
{ "tstzrange",DbType.String},
|
|
{ "daterange",DbType.String}
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// PostgreSQL的 数据类型对应CSharpype 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_PostgreSql_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "smallint","int" },
|
|
{ "integer","int"},
|
|
{ "bigint","long" },
|
|
{ "decimal","decimal"},
|
|
{ "numeric","decimal" },
|
|
{ "real","decimal" },
|
|
{ "double precision","double" },
|
|
{ "smallserial","int" },
|
|
{ "serial","int" },
|
|
{ "bigserial","long" },
|
|
|
|
{ "money","decimal" },
|
|
|
|
{ "character varying","string" },
|
|
{ "character","string" },
|
|
{ "text","string" },
|
|
|
|
{ "bytea","byte[]" },
|
|
|
|
{ "timestamp","DateTime" },
|
|
{ "date","DateTime" },
|
|
{ "time","string" },
|
|
{ "interval","int"},
|
|
|
|
{ "boolean","bool" },
|
|
|
|
{ "enum","int" },
|
|
|
|
{ "point","object"},
|
|
{ "line","object"},
|
|
{ "lseg","object"},
|
|
{ "box","object"},
|
|
{ "path","object"},
|
|
{ "polygon","object"},
|
|
{ "circle","object"},
|
|
|
|
{ "cidr","string"},//IPv4和IPv6网络
|
|
{ "inet","string"},//IPv4和IPv6主机以及网络
|
|
{ "macaddr","string"},//MAC地址
|
|
|
|
{ "bit","bool"},
|
|
{ "bit varying","string"},
|
|
|
|
{ "tsvector","string"},
|
|
{ "tsquery","string"},
|
|
|
|
{ "UUID","Guid"},
|
|
|
|
{ "Xml","string"},
|
|
|
|
{ "json","string"},
|
|
{ "jsonb","string"},
|
|
|
|
{ "int4range","string"},
|
|
{ "int8range","string"},
|
|
{ "numrange","string"},
|
|
{ "tsrange","string"},
|
|
{ "tstzrange","string"},
|
|
{ "daterange","string"}
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// PostgreSql的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_PostgreSql_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// Sqlite的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_Sqlite_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "int",DbType.Int32},
|
|
{ "integer",DbType.Int32},
|
|
{ "tinyint",DbType.Byte},
|
|
{ "smallint",DbType.Int16},
|
|
{ "mediumint",DbType.Int32},
|
|
{ "bitint",DbType.Int64},
|
|
{ "unsigned big int",DbType.Int64},
|
|
{ "int2",DbType.Int32},
|
|
{ "int8",DbType.Int64},
|
|
|
|
{ "character",DbType.AnsiStringFixedLength},
|
|
{ "varchar",DbType.AnsiStringFixedLength},
|
|
{ "varying character",DbType.AnsiStringFixedLength},
|
|
{ "nchar",DbType.StringFixedLength},
|
|
{ "native character",DbType.StringFixedLength},
|
|
{ "nvarchar",DbType.StringFixedLength},
|
|
{ "text",DbType.String},
|
|
{ "clob",DbType.String},
|
|
|
|
|
|
{ "blob",DbType.Binary},
|
|
{ "no datatype specified",DbType.Object},
|
|
|
|
{ "real",DbType.Single},
|
|
{ "double",DbType.Decimal},
|
|
{ "double precision",DbType.Double},
|
|
{ "float",DbType.Single},
|
|
|
|
{ "numeric",DbType.Decimal},
|
|
{ "decimal",DbType.Decimal},
|
|
{ "boolean",DbType.Boolean},
|
|
{ "date",DbType.Date},
|
|
{ "datetime",DbType.DateTime}
|
|
};
|
|
|
|
/// <summary>
|
|
/// Sqlite的 数据类型对应CSharpType 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_Sqlite_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "int","int"},
|
|
{ "integer","int"},
|
|
{ "tinyint","int"},
|
|
{ "smallint","int"},
|
|
{ "mediumint","int"},
|
|
{ "bitint","long"},
|
|
{ "unsigned big int","long"},
|
|
{ "int2","int"},
|
|
{ "int8","long"},
|
|
|
|
{ "character","string"},
|
|
{ "varchar","string"},
|
|
{ "varying character","string"},
|
|
{ "nchar","string"},
|
|
{ "native character","string"},
|
|
{ "nvarchar","string"},
|
|
{ "text","string"},
|
|
{ "clob","string"},
|
|
|
|
|
|
{ "blob","byte[]"},
|
|
{ "no datatype specified","object"},
|
|
|
|
{ "real","decimal"},
|
|
{ "double","double"},
|
|
{ "double precision","double"},
|
|
{ "float","float"},
|
|
|
|
{ "numeric","decimal"},
|
|
{ "decimal","decimal"},
|
|
{ "boolean","bool"},
|
|
{ "date","DateTime"},
|
|
{ "datetime","DateTime"}
|
|
};
|
|
|
|
|
|
/// <summary>
|
|
/// Sqlite的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_Sqlite_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
|
|
};
|
|
|
|
/// <summary>
|
|
/// DB2的 数据类型对应DbType字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, DbType> Dict_DB2_DbType = new Dictionary<string, DbType>()
|
|
{
|
|
{ "CHAR",DbType.AnsiStringFixedLength },
|
|
{ "CHARACTER",DbType.AnsiStringFixedLength },
|
|
{ "VARCHAR",DbType.AnsiStringFixedLength },
|
|
{ "LONG VARCHAR",DbType.AnsiStringFixedLength },
|
|
|
|
{ "GRAPHIC",DbType.String },
|
|
{ "VARGRAPHIC",DbType.String },
|
|
{ "LONG GRAPHIC",DbType.String },
|
|
|
|
{ "DATE",DbType.DateTime },
|
|
{ "TIMESTAMP",DbType.DateTime },
|
|
|
|
{ "SMALLINT",DbType.Int32 },
|
|
{ "INTEGER",DbType.Int32 },
|
|
{ "BIGINT",DbType.Int64 },
|
|
|
|
{ "BLOB",DbType.Binary },//保存2GB长度以内的二进制数据。
|
|
{ "CLOB",DbType.AnsiString },//保存2GB长度以内的单字节文本数据
|
|
{ "DBCLOB",DbType.String },//保存1GB长度以内的双字节文本数据。
|
|
|
|
{ "NUMBER",DbType.Decimal },
|
|
{ "DOUBLE",DbType.Decimal },
|
|
{ "DECIMAL",DbType.Decimal },
|
|
{ "FLOAT",DbType.Decimal },
|
|
{ "REAL",DbType.Decimal }
|
|
};
|
|
|
|
/// <summary>
|
|
/// DB2的 数据类型对应CSharpType 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_DB2_CSharpType = new Dictionary<string, string>()
|
|
{
|
|
{ "CHAR","string" },
|
|
{ "CHARACTER","string" },
|
|
{ "VARCHAR","string" },
|
|
{ "LONG VARCHAR","string" },
|
|
|
|
{ "GRAPHIC","string" },
|
|
{ "VARGRAPHIC","string" },
|
|
{ "LONG GRAPHIC","string" },
|
|
|
|
{ "DATE","DateTime" },
|
|
{ "TIMESTAMP","DateTime" },
|
|
|
|
{ "SMALLINT","int" },
|
|
{ "INTEGER","int" },
|
|
{ "BIGINT","long" },
|
|
|
|
{ "BLOB","byte[]" },//保存2GB长度以内的二进制数据。
|
|
{ "CLOB","string" },//保存2GB长度以内的单字节文本数据
|
|
{ "DBCLOB","string" },//保存1GB长度以内的双字节文本数据。
|
|
|
|
{ "NUMBER","decimal" },
|
|
{ "DOUBLE","decimal" },
|
|
{ "DECIMAL","decimal" },
|
|
{ "FLOAT","decimal" },
|
|
{ "REAL","decimal" }
|
|
};
|
|
|
|
/// <summary>
|
|
/// DB2的 数据类型对应 默认值 字典
|
|
/// </summary>
|
|
public readonly static Dictionary<string, string> Dict_DB2_DefValue = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
|
|
};
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// DbType对应的转换方法
|
|
/// </summary>
|
|
public readonly static Dictionary<DbType, Func<object, object>> Dict_Convert_Type = new Dictionary<DbType, Func<object, object>>()
|
|
{
|
|
{ DbType.AnsiString,
|
|
(obj) => obj.ToString()
|
|
},
|
|
{ DbType.Binary,
|
|
(obj) => obj
|
|
},
|
|
{ DbType.Byte,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
byte res;
|
|
if (byte.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Boolean, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
bool res;
|
|
if (bool.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Currency, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
decimal res;
|
|
if (decimal.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Date, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
DateTime res;
|
|
if (DateTime.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.DateTime, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
DateTime res;
|
|
if (DateTime.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Decimal, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
decimal res;
|
|
if (decimal.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Double, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
decimal res;
|
|
if (decimal.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Guid, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
Guid res;
|
|
if (Guid.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Int16,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Int32,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Int64,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
long res;
|
|
if (long.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Object,
|
|
(obj)=>obj
|
|
},
|
|
{ DbType.SByte,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.Single,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.String,
|
|
(obj)=>obj.ToString()
|
|
},
|
|
{ DbType.Time,
|
|
(obj)=>obj.ToString()
|
|
},
|
|
{ DbType.UInt16,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.UInt32,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
int res;
|
|
if (int.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.UInt64,(obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
long res;
|
|
if (long.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
//{ DbType.VarNumeric, (obj) =>
|
|
// {
|
|
// if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
// {
|
|
// return DBNull.Value;
|
|
// }
|
|
|
|
// decimal res;
|
|
// if (decimal.TryParse(obj.ToString(), out res))
|
|
// {
|
|
// return res;
|
|
// }
|
|
// return new ArgumentException(obj + "类型转换失败！");
|
|
// }
|
|
//},
|
|
{ DbType.AnsiStringFixedLength,
|
|
(obj)=>obj.ToString()
|
|
},
|
|
{ DbType.StringFixedLength,
|
|
(obj)=>obj.ToString()
|
|
},
|
|
{ DbType.Xml,
|
|
(obj)=>obj.ToString()
|
|
},
|
|
{ DbType.DateTime2, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
DateTime res;
|
|
if (DateTime.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
{ DbType.DateTimeOffset, (obj) =>
|
|
{
|
|
if (obj == null || string.IsNullOrWhiteSpace(obj.ToString()))
|
|
{
|
|
return DBNull.Value;
|
|
}
|
|
|
|
DateTime res;
|
|
if (DateTime.TryParse(obj.ToString(), out res))
|
|
{
|
|
return res;
|
|
}
|
|
return new ArgumentException(obj + "类型转换失败！");
|
|
}
|
|
},
|
|
};
|
|
}
|
|
}
|