public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <TimeSpan>(DbType.DateTime, TimeColumnDefinition);
DbTypeMap.Set <TimeSpan?>(DbType.DateTime, TimeColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <bool>(DbType.Int16, BoolColumnDefinition);
DbTypeMap.Set <bool?>(DbType.Int16, BoolColumnDefinition);
DbTypeMap.Set <sbyte>(DbType.Int16, IntColumnDefinition);
DbTypeMap.Set <sbyte?>(DbType.Int16, IntColumnDefinition);
DbTypeMap.Set <ushort>(DbType.Int32, IntColumnDefinition);
DbTypeMap.Set <ushort?>(DbType.Int32, IntColumnDefinition);
DbTypeMap.Set <uint>(DbType.Int64, LongColumnDefinition);
DbTypeMap.Set <uint?>(DbType.Int64, LongColumnDefinition);
DbTypeMap.Set <ulong>(DbType.Int64, LongColumnDefinition);
DbTypeMap.Set <ulong?>(DbType.Int64, LongColumnDefinition);
if (CompactGuid)
{
DbTypeMap.Set <Guid>(DbType.Binary, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.Binary, GuidColumnDefinition);
}
else
{
DbTypeMap.Set <Guid>(DbType.String, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.String, GuidColumnDefinition);
}
DbTypeMap.Set <DateTimeOffset>(DbType.String, DateTimeOffsetColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.String, DateTimeOffsetColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
DbTypeMap.Set <Guid>(DbType.String, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.String, GuidColumnDefinition);
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, StringColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.DateTimeOffset, StringColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <DateTime>(DbType.DateTime, "DATETIME");
DbTypeMap.Set <DateTime?>(DbType.DateTime, "DATETIME");
DbTypeMap.Set <bool>(DbType.Boolean, "BOOLEAN");
}
public SqlCeSyntaxProvider()
{
BlobColumnDefinition = "IMAGE";
// This is silly to have to do this but the way these inherited classes are structured it's the easiest
// way without an overhaul in type map initialization
DbTypeMap.Set <byte[]>(DbType.Binary, BlobColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
}
private Dictionary <string, DbTypeMap> GetDestinationSchema(string tableName, string schemaName, SqlConnection connection, SqlTransaction transaction)
{
var types = new Dictionary <string, DbTypeMap>();
string sql = $"SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.columns c where c.TABLE_NAME = '{tableName}'";
using (SqlCommand command = new SqlCommand(sql, connection, transaction))
{
using SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
var dbTypeMap = new DbTypeMap
{
ColumnName = reader.GetString(0),
SqlTypeName = reader.GetString(1)
};
var dotnetType = MapSqlTypeToNative(dbTypeMap.SqlTypeName);
if (dotnetType == null)
{
//not supported types: xml, rowversion, sql_variant, image, varbinary(max), binary, varbinary, timestamp
throw new NotSupportedException($"SqlServerBulkImportService: Data type '{dbTypeMap.SqlTypeName}' on destination table {schemaName}.{tableName} is not support for bulk import operations.");
}
else
{
dbTypeMap.DotnetType = dotnetType;
types.Add(dbTypeMap.ColumnName, dbTypeMap);
}
}
}
return(types);
}
// <summary>
// Get the type usage for this parameter in model terms.
// </summary>
// <returns> The type usage for this parameter </returns>
// <remarks>
// Because GetTypeUsage throws CommandValidationExceptions, it should only be called from EntityCommand during command execution
// </remarks>
internal virtual TypeUsage GetTypeUsage()
{
TypeUsage typeUsage;
if (!IsTypeConsistent)
{
throw new InvalidOperationException(
Strings.EntityClient_EntityParameterInconsistentEdmType(
_edmType.FullName, _parameterName));
}
if (_edmType != null)
{
typeUsage = TypeUsage.Create(_edmType);
}
else if (!DbTypeMap.TryGetModelTypeUsage(DbType, out typeUsage))
{
// Spatial and HierarchyId types have only DbType 'Object', and cannot be represented in the static type map.
PrimitiveType primitiveParameterType;
if (DbType == DbType.Object &&
Value != null &&
ClrProviderManifest.Instance.TryGetPrimitiveType(Value.GetType(), out primitiveParameterType) &&
(Helper.IsSpatialType(primitiveParameterType) || Helper.IsHierarchyIdType(primitiveParameterType)))
{
typeUsage = EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(primitiveParameterType.PrimitiveTypeKind);
}
else
{
throw new InvalidOperationException(Strings.EntityClient_UnsupportedDbType(DbType.ToString(), ParameterName));
}
}
Debug.Assert(typeUsage != null, "DbType.TryGetModelTypeUsage returned true for null TypeUsage?");
return(typeUsage);
}
/// <summary>
/// Prevents a default instance of the NServiceKit.OrmLite.PostgreSQL.PostgreSQLDialectProvider
/// class from being created.
/// </summary>
public PostgreSQLDialectProvider()
{
base.AutoIncrementDefinition = "";
base.IntColumnDefinition = "integer";
base.BoolColumnDefinition = "boolean";
base.TimeColumnDefinition = "time";
base.DateTimeColumnDefinition = "timestamp";
base.DecimalColumnDefinition = "numeric(38,6)";
base.GuidColumnDefinition = "uuid";
base.ParamPrefix = ":";
base.BlobColumnDefinition = "bytea";
base.RealColumnDefinition = "double precision";
base.StringLengthColumnDefinitionFormat = textColumnDefinition;
//there is no "n"varchar in postgres. All strings are either unicode or non-unicode, inherited from the database.
base.StringLengthUnicodeColumnDefinitionFormat = "character varying({0})";
base.StringLengthNonUnicodeColumnDefinitionFormat = "character varying({0})";
base.InitColumnTypeMap();
base.SelectIdentitySql = "SELECT LASTVAL()";
this.NamingStrategy = new PostgreSqlNamingStrategy();
DbTypeMap.Set(DbType.Time, "Interval");
DbTypeMap.Set(DbType.Time, "Interval");
DefaultStringLength = 255;
}
private static void SetupCommand(IDbCommand cmd, string sql, object parm = null)
{
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
if (parm != null)
{
var paramters = GetParamters(parm).parameters;
foreach (var item in paramters.Values)
{
var p = cmd.CreateParameter();
p.ParameterName = item.Name;
p.Value = item.Value;
var dbType = item.DbType;
//查找DbType
if (dbType == null && item.Value != null)
{
dbType = DbTypeMap.Lookup(item.Value.GetType());
}
if (dbType.HasValue)
{
p.DbType = dbType.Value;
}
if (item.Size.HasValue)
{
p.Size = item.Size.Value;
}
if (item.Direction.HasValue)
{
p.Direction = item.Direction.Value;
}
cmd.Parameters.Add(p);
}
}
}
/// <summary>
/// Creates an instance of DbValue.
/// </summary>
/// <param name="fieldName"></param>
/// <param name="key"></param>
/// <param name="identity"></param>
public DbFieldValue(string fieldName, bool key, bool identity)
{
FieldName = fieldName;
IsKey = key;
IsIdentity = identity;
FieldType = DbTypeMap.ToDbType(GetValueType());
}
public override void OnAfterInitColumnTypeMap()
{
DbTypeMap.Set <TimeSpan>(DbType.Time, "interval");
DbTypeMap.Set <TimeSpan?>(DbType.Time, "interval");
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
base.OnAfterInitColumnTypeMap();
}
public override void OnAfterInitColumnTypeMap()
{
DbTypeMap.Set <TimeSpan>(DbType.String, StringColumnDefinition);
DbTypeMap.Set <TimeSpan?>(DbType.String, StringColumnDefinition);
DbTypeMap.Set <Guid>(DbType.String, StringColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.String, StringColumnDefinition);
return;
DbTypeMap.Set <DateTime>(DbType.String, StringColumnDefinition);
DbTypeMap.Set <DateTime?>(DbType.String, StringColumnDefinition);
}
public override void UpdateStringColumnDefinitions()
{
base.UpdateStringColumnDefinitions();
base.DateTimeColumnDefinition = base.StringColumnDefinition;
DbTypeMap.Set <DateTime>(DbType.DateTimeOffset, DateTimeColumnDefinition);
DbTypeMap.Set <DateTime?>(DbType.DateTimeOffset, DateTimeColumnDefinition);
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, DateTimeColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.DateTimeOffset, DateTimeColumnDefinition);
this.MaxStringColumnDefinition = string.Format(this.StringLengthColumnDefinitionFormat, "1000000"); //Default Max is really 1B
}
/// <summary>
/// Initializes a new instance of the NServiceKit.OrmLite.Sqlite.SqliteOrmLiteDialectProviderBase
/// class.
/// </summary>
public SqliteDialectProvider()
{
base.DateTimeColumnDefinition = base.StringColumnDefinition;
base.BoolColumnDefinition = base.IntColumnDefinition;
//base.GuidColumnDefinition = "GUID";
base.SelectIdentitySql = "SELECT last_insert_rowid()";
base.InitColumnTypeMap();
// add support for DateTimeOffset
DbTypeMap.Set(DbType.DateTimeOffset, StringColumnDefinition);
DbTypeMap.Set(DbType.DateTimeOffset, StringColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <TimeSpan>(DbType.DateTime, TimeColumnDefinition);
DbTypeMap.Set <TimeSpan?>(DbType.DateTime, TimeColumnDefinition);
//throws unknown type exceptions in parameterized queries, e.g: p.DbType = DbType.SByte
DbTypeMap.Set <sbyte>(DbType.Byte, IntColumnDefinition);
DbTypeMap.Set <ushort>(DbType.Int16, IntColumnDefinition);
DbTypeMap.Set <uint>(DbType.Int32, IntColumnDefinition);
DbTypeMap.Set <ulong>(DbType.Int64, LongColumnDefinition);
}
/// <summary>
/// Initializes a new instance of the NServiceKit.OrmLite.Sqlite.SqliteOrmLiteDialectProviderBase
/// class.
/// </summary>
protected SqliteOrmLiteDialectProviderBase()
{
base.DateTimeColumnDefinition = base.StringColumnDefinition;
base.BoolColumnDefinition = base.IntColumnDefinition;
base.GuidColumnDefinition = "CHAR(32)";
base.SelectIdentitySql = "SELECT last_insert_rowid()";
base.InitColumnTypeMap();
// add support for DateTimeOffset
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, StringColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.DateTimeOffset, StringColumnDefinition);
}
public static string GetNetType(string dbServerType, string columnTypeName)
{
dbServerType = dbServerType.ToUpper();
columnTypeName = columnTypeName.ToUpper();
if (DbTypeMap.ContainsKey(dbServerType) && DbTypeMap[dbServerType].ContainsKey(columnTypeName))
{
return(DbTypeMap[dbServerType][columnTypeName]);
}
else
{
return(null);
}
}
/// <summary>
/// Creates a new instance of DbParameter[] with ParameterName, Value and IsNullable properties
/// sets to value's properties.
/// </summary>
/// <typeparam name="T">Type of object with properties to convert in Parameters</typeparam>
/// <typeparam name="U">DbParameter type (SqlParameter, ...)</typeparam>
/// <param name="command"></param>
/// <param name="value"></param>
/// <returns></returns>
private static IEnumerable <DbParameter> ToParameters <T, U>(DbCommand command, T value) where U : DbParameter
{
if (TypeExtension.IsPrimitive(typeof(T)))
{
throw new ArgumentException("The value can not be a simple type (string, int, ...), but an object with simple properties.", "value");
}
else
{
List <DbParameter> parameters = new List <DbParameter>();
foreach (PropertyInfo property in typeof(T).GetProperties())
{
if (TypeExtension.IsPrimitive(property.PropertyType))
{
// Data type
Type propType = TypeExtension.GetNullableSubType(property.PropertyType);
// Value
DbParameter parameter = command != null?
command.CreateParameter() :
Activator.CreateInstance(typeof(U)) as DbParameter;
parameter.Value = typeof(T).GetProperty(property.Name).GetValue(value, null);
parameter.IsNullable = TypeExtension.IsNullable(property.PropertyType);
parameter.DbType = DbTypeMap.FirstDbType(propType);
if (parameter.IsNullable && parameter.Value == null)
{
parameter.Value = DBNull.Value;
}
// Parameter name
string attribute = Apps72.Dev.Data.Annotations.ColumnAttribute.GetColumnAttributeName(property);
if (string.IsNullOrEmpty(attribute))
{
parameter.ParameterName = property.Name;
}
else
{
parameter.ParameterName = attribute;
}
parameters.Add(parameter);
}
}
return(parameters.AsEnumerable());
}
}
protected virtual DbType GetDBType(Type type)
{
if (type.IsEnum)
{
return(DbType.Int32);
}
Type t = Types.GetUnderlyingType(type);
DbType dbType;
if (DbTypeMap.TryGetValue(t, out dbType))
{
return(dbType);
}
throw new InvalidCastException("Error converting system type '" + type.ToString() + "' to an SQL type.");
}
/// <summary>
/// Initializes a new instance of the
/// NServiceKit.OrmLite.SqlServer.SqlServerOrmLiteDialectProvider class.
/// </summary>
public SqlServerDialectProvider()
{
base.AutoIncrementDefinition = "IDENTITY(1,1)";
StringColumnDefinition = UseUnicode ? "NVARCHAR(4000)" : "VARCHAR(8000)";
base.GuidColumnDefinition = "UniqueIdentifier";
base.RealColumnDefinition = "FLOAT";
base.BoolColumnDefinition = "BIT";
base.DecimalColumnDefinition = "DECIMAL(38,6)";
base.TimeColumnDefinition = "TIME"; //SQLSERVER 2008+
base.BlobColumnDefinition = "VARBINARY(MAX)";
base.SelectIdentitySql = "SELECT SCOPE_IDENTITY()";
base.InitColumnTypeMap();
// add support for DateTimeOffset
DbTypeMap.Set(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
DbTypeMap.Set(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
}
public void Build()
{
if (DbType == null && _clrType != null)
{
DbType = DbTypeMap.Map(_clrType);
}
var attr = new Attribute(_clrType, Name, _databaseName, PropertyInfo, DbType, _isAutoInc)
{
DeclaredIn = Entity
};
_context.Attributes.GetOrInsert(Entity.EntityName, new Dictionary <string, Attribute>())[Name] = attr;
if (IsPrimaryKey())
{
attr.DeclaredIn.PrimaryKeyAttribute = attr;
}
}
private PostgreSQLDialectProvider()
{
base.AutoIncrementDefinition = "";
base.IntColumnDefinition = "integer";
base.BoolColumnDefinition = "boolean";
base.TimeColumnDefinition = "time";
base.DateTimeColumnDefinition = "timestamp";
base.DecimalColumnDefinition = "numeric(38,6)";
base.GuidColumnDefinition = "uuid";
base.ParamString = ":";
base.BlobColumnDefinition = "bytea";
base.RealColumnDefinition = "double precision";
base.StringLengthColumnDefinitionFormat = "text";
base.InitColumnTypeMap();
DbTypeMap.Set <TimeSpan>(DbType.Time, "Interval");
DbTypeMap.Set <TimeSpan?>(DbType.Time, "Interval");
}
public override void OnAfterInitColumnTypeMap()
{
base.OnAfterInitColumnTypeMap();
DbTypeMap.Set <bool>(DbType.Int16, BoolColumnDefinition);
DbTypeMap.Set <bool?>(DbType.Int16, BoolColumnDefinition);
if (CompactGuid)
{
DbTypeMap.Set <Guid>(DbType.Binary, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.Binary, GuidColumnDefinition);
}
else
{
DbTypeMap.Set <Guid>(DbType.String, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.String, GuidColumnDefinition);
}
DbTypeMap.Set <DateTimeOffset>(DbType.String, DateTimeOffsetColumnDefinition);
DbTypeMap.Set <DateTimeOffset?>(DbType.String, DateTimeOffsetColumnDefinition);
}
/// <summary>
/// NotesDateBaseの変換先のSPListタイプを取得する
/// </summary>
/// <param name="dbType"></param>
/// <returns></returns>
public static SPListType GetTagetDbType(NotesDbType dbType)
{
string typeName = dbType.ToString();
var result = DbTypeMap.Where(row => row.NotesDbType == typeName);
if (result.Count() == 0)
{
result = DbTypeMap.Where(row => row.NotesDbType == "DEFAULT");
}
SPListType type = SPListType.InvalidType;
if (result.Count() > 0 && result.First().CanConvert)
{
if (Enum.TryParse(result.First().SPListType, out type))
{
return(type);
}
}
return(SPListType.InvalidType);
}
private PostgreSQLDialectProvider()
{
base.AutoIncrementDefinition = "";
base.IntColumnDefinition = "integer";
base.BoolColumnDefinition = "boolean";
base.TimeColumnDefinition = "time";
base.DateTimeColumnDefinition = "timestamp";
base.DecimalColumnDefinition = "numeric(38,6)";
base.GuidColumnDefinition = "uuid";
base.ParamString = ":";
base.BlobColumnDefinition = "bytea";
base.RealColumnDefinition = "double precision";
base.StringLengthColumnDefinitionFormat = textColumnDefinition;
//there is no "n"varchar in postgres. All strings are either unicode or non-unicode, inherited from the database.
base.StringLengthUnicodeColumnDefinitionFormat = "character varying({0})";
base.StringLengthNonUnicodeColumnDefinitionFormat = "character varying({0})";
base.InitColumnTypeMap();
DbTypeMap.Set <TimeSpan>(DbType.Time, "Interval");
DbTypeMap.Set <TimeSpan?>(DbType.Time, "Interval");
}
internal virtual TypeUsage GetTypeUsage()
{
if (!this.IsTypeConsistent)
{
throw new InvalidOperationException(Strings.EntityClient_EntityParameterInconsistentEdmType((object)this._edmType.FullName, (object)this._parameterName));
}
TypeUsage modelType;
if (this._edmType != null)
{
modelType = TypeUsage.Create(this._edmType);
}
else if (!DbTypeMap.TryGetModelTypeUsage(this.DbType, out modelType))
{
PrimitiveType primitiveType;
if (this.DbType != DbType.Object || this.Value == null || (!ClrProviderManifest.Instance.TryGetPrimitiveType(this.Value.GetType(), out primitiveType) || !Helper.IsSpatialType(primitiveType)))
{
throw new InvalidOperationException(Strings.EntityClient_UnsupportedDbType((object)this.DbType.ToString(), (object)this.ParameterName));
}
modelType = EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(primitiveType.PrimitiveTypeKind);
}
return(modelType);
}
public TableGenerator(Schema schema, DbTypeMap map)
{
#region Preconditions
if (schema == null)
throw new ArgumentNullException(nameof(schema));
if (map == null)
throw new ArgumentNullException(nameof(map));
#endregion
Name = schema.Name;
foreach (var column in schema.Members)
{
var col = new ColumnDefinition(column, map.Get(column));
Columns.Add(col);
}
PrimaryKey = schema.Key;
Indexes = schema.Indexes;
}
public CustomSqlServerOrmLiteDialectProvider()
{
DbTypeMap.Set <DateTimeOffset>(DbType.DateTimeOffset, DateTimeOffsetColumnDefinition);
}
public override void OnAfterInitColumnTypeMap()
{
DbTypeMap.Set <Guid>(DbType.String, GuidColumnDefinition);
DbTypeMap.Set <Guid?>(DbType.String, GuidColumnDefinition);
}
