private static bool CovertDataValue(SchemaTable schemaTable, SchemaColumn schemaColumn, ref object value)
{
if (value is DateTime && value.ToDateTime() < MathUtils.SqlMinDate)
{
return(false);
}
//序列化Json
if (schemaColumn.IsSerialized)
{
if (schemaColumn.DbType == ColumnDbType.LongBlob || schemaColumn.DbType == ColumnDbType.Blob)
{
value = SerializeBinaryObject(schemaTable, schemaColumn, value);
}
else
{
value = SerializeJson(schemaTable, schemaColumn, value);
}
if (value == null)
{
return(false);
}
}
return(true);
}
private static object DeserializeJsonObject(SchemaTable schemaTable, AbstractEntity entity, object value,
SchemaColumn fieldAttr, string columnName)
{
try
{
if (fieldAttr.ColumnType.IsSubclassOf(typeof(Array)))
{
value = value.ToString().StartsWith("[") ? value : "[" + value + "]";
}
string tempValue = value.ToNotNullString();
if (!string.IsNullOrEmpty(fieldAttr.JsonDateTimeFormat) &&
tempValue.IndexOf(@"\/Date(") == -1)
{
return(JsonUtils.DeserializeCustom(tempValue, fieldAttr.ColumnType, fieldAttr.JsonDateTimeFormat));
}
else
{
return(JsonUtils.Deserialize(tempValue, fieldAttr.ColumnType));
}
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} key:{1} column:{2} deserialize json error:{3} to {4}\r\nException:{5}",
schemaTable.EntityName,
entity.GetKeyCode(),
columnName,
value,
fieldAttr.ColumnType.FullName,
ex);
}
return(null);
}
private static bool CovertDataValue(SchemaTable schemaTable, SchemaColumn schemaColumn, ref object value)
{
if (value is DateTime && value.ToDateTime() < MathUtils.SqlMinDate)
{
return(false);
}
//序列化Json
if (schemaColumn.IsJson)
{
try
{
value = value ?? string.Empty;
if (!string.IsNullOrEmpty(schemaColumn.JsonDateTimeFormat))
{
value = JsonUtils.SerializeCustom(value);
}
else
{
value = JsonUtils.Serialize(value);
}
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} column:\"{0}\" json serialize error:\r\n:{1}",
schemaTable.Name,
schemaColumn.Name,
ex);
return(false);
}
}
return(true);
}
private void SetEntityValue(AbstractEntity entity, SchemaColumn fieldAttr, object value)
{
string columnName = fieldAttr.Name;
object fieldValue;
if (fieldAttr.IsSerialized)
{
//指定序列化方式
if (fieldAttr.DbType == ColumnDbType.LongBlob || fieldAttr.DbType == ColumnDbType.Blob)
{
fieldValue = DeserializeBinaryObject(value, fieldAttr);
}
else
{
fieldValue = DeserializeJsonObject(value, fieldAttr);
}
if (fieldValue is EntityChangeEvent)
{
((EntityChangeEvent)fieldValue).PropertyName = columnName;
}
}
else
{
fieldValue = AbstractEntity.ParseValueType(value, fieldAttr.ColumnType);
}
if (fieldAttr.CanWrite)
{
entity.SetPropertyValue(columnName, fieldValue);
}
else
{
entity.SetFieldValue(columnName, fieldValue);
}
}
/// <summary>
/// Adds a column
/// </summary>
public Builder AddColumn(string name, DbType type, bool allowNull = true, int size = -1)
{
var col = new SchemaColumn(name, type, allowNull);
this.columns.Add(col);
return(this);
}
/// <summary>
/// Carga las columnas de la vista
/// </summary>
private void LoadColumns(SQLServerProvider objConnection, SchemaView objView)
{
ParametersDBCollection objColParameters = new ParametersDBCollection();
string strSQL;
// Asigna lo parámetros
objColParameters.Add("@View_Catalog", objView.Catalog);
objColParameters.Add("@View_Schema", objView.Schema);
objColParameters.Add("@View_Name", objView.Name);
// Crea la cadena SQL
strSQL = @"SELECT Table_Catalog, Table_Schema, Table_Name, Column_Name
FROM Information_Schema.View_Column_Usage
WHERE View_Catalog = @View_Catalog
AND View_Schema = @View_Schema
AND View_Name = @View_Name" ;
// Carga las columnas
using (IDataReader rdoColumns = objConnection.ExecuteReader(strSQL, objColParameters, CommandType.Text))
{ // Lee los registros
while (rdoColumns.Read())
{
SchemaColumn objColumn = new SchemaColumn(objView.Parent);
// Carga los datos de la columna
objColumn.Catalog = (string)rdoColumns.IisNull("Table_Catalog");
objColumn.Schema = (string)rdoColumns.IisNull("Table_Schema");
objColumn.Table = (string)rdoColumns.IisNull("Table_Name");
objColumn.Name = (string)rdoColumns.IisNull("Column_Name");
// Añade la columna a la colección
objView.Columns.Add(objColumn);
}
// Cierra el recordset
rdoColumns.Close();
}
}
private string BuildUpdateColumn(SchemaColumn column)
{
var sb = new StringBuilder();
sb.Append(column.Name).Append(" ").Append(column.DbTypeNormalized)
.Append(column.Nullable ? " NULL" : " NOT NULL");
return(sb.ToString());
}
protected virtual object GetFieldValue(DbDataReader rdr, int ordinal, SchemaColumn col)
{
switch (col.Column.DataType)
{
case SQDataTypes.Boolean:
return(rdr.GetBoolean(ordinal));
case SQDataTypes.Bytes:
MemoryStream ms = new MemoryStream();
byte[] bytes = new byte[8000];
long read = 0;
while ((read = rdr.GetBytes(ordinal, 0, bytes, 0, bytes.Length)) > 0)
{
ms.Write(bytes, 0, Convert.ToInt32(read));
}
if (col.Property.PropertyType == typeof(byte[]))
{
return(ms.ToArray());
}
return(ms.ToArray());
break;
case SQDataTypes.DateTime:
return(rdr.GetDateTime(ordinal));
case SQDataTypes.Decimal:
return(rdr.GetDecimal(ordinal));
case SQDataTypes.Float:
return(rdr.GetFloat(ordinal));
case SQDataTypes.Int16:
Int16 small = rdr.GetInt16(ordinal);
if (col.Property.PropertyType == typeof(Byte))
{
return(Convert.ToByte(small));
}
return(small);
case SQDataTypes.Int32:
return(rdr.GetInt32(ordinal));
case SQDataTypes.Int64:
Int64 value = rdr.GetInt64(ordinal);
if (col.Property.PropertyType.IsEnum)
{
return(Enum.ToObject(col.Property.PropertyType, value));
}
return(value);
case SQDataTypes.String:
return(rdr.GetString(ordinal));
}
return(null);
}
private object DeserializeBinaryObject(object value, SchemaColumn fieldAttr)
{
if (value is byte[])
{
byte[] buffer = value as byte[];
return(ProtoBufUtils.Deserialize(buffer, fieldAttr.ColumnType));
}
throw new Exception(string.Format("The {0} column value is not byte[] type.", fieldAttr.Name));
}
private static string MapDataType(SchemaColumn column)
{
return(column.DataType switch
{
"text" or "varchar" => "string",
"date" or "datetime" or "timestamp" => "date",
"bit" => "boolean",
"tinyint" or "smallint" or "mediumint" or "int" or "bigint" or "decimal" or "double" => "numeric",
_ => "unknown",
});
private object GetPropertyValue <T>(T data, SchemaColumn column) where T : ISqlEntity
{
object value = null;
if (data is AbstractEntity)
{
value = (data as AbstractEntity).GetPropertyValue(column.CanRead, column.Name);
CovertDataValue(column, ref value);
}
return(value);
}
/* Methods */
/// <inheritdoc />
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
SchemaColumn column = value as SchemaColumn;
if (column == null)
{
return(null);
}
return(new SchemaColumn[] { column });
}
/// <summary>
/// Obtiene el tipo de datos de una columna
/// </summary>
private string GetDataType(SchemaColumn objColumn)
{
string strType = objColumn.DataType;
// Añade los datos
if (objColumn.CharacterMaximumLength > 0)
{
strType += $"({objColumn.CharacterMaximumLength})";
}
// Devuelve el tipo
return(strType);
}
private void SetPropertyFunc <T>(T entity, SchemaColumn column, object fieldValue) where T : new()
{
var t = entity as AbstractEntity;
if (t != null)
{
t.Init();
t.SetValueBefore();
SetEntityValue(t, column, fieldValue);
t.SetValueAfter();
}
}
/// <summary>
/// Comprueba si una columna es una clave foránea
/// </summary>
private bool CheckIsForeignKey(SchemaTable objTable, SchemaColumn objColumn)
{ // Recorre las restricciones comprobando si es una clave foránea
foreach (SchemaConstraint objConstraint in objTable.Constraints)
{
if (objConstraint.Type == SchemaConstraint.ConstraintType.ForeignKey &&
objColumn.Name.EqualsIgnoreCase(objConstraint.Column))
{
return(true);
}
}
// Si ha llegado hasta aquí es porque no es una clave foránea
return(false);
}
private static object SerializeJson(SchemaColumn schemaColumn, object value)
{
value = value ?? string.Empty;
if (!string.IsNullOrEmpty(schemaColumn.JsonDateTimeFormat))
{
value = JsonUtils.SerializeCustom(value);
}
else
{
value = JsonUtils.Serialize(value);
}
return(value);
}
private static object DeserializeJsonObject(object value, SchemaColumn fieldAttr)
{
if (fieldAttr.ColumnType.IsSubclassOf(typeof(Array)))
{
value = value.ToString().StartsWith("[") ? value : "[" + value + "]";
}
string tempValue = value.ToNotNullString();
if (!string.IsNullOrEmpty(fieldAttr.JsonDateTimeFormat) &&
tempValue.IndexOf(@"\/Date(", StringComparison.Ordinal) == -1)
{
return(JsonUtils.DeserializeCustom(tempValue, fieldAttr.ColumnType, fieldAttr.JsonDateTimeFormat));
}
return(JsonUtils.Deserialize(tempValue, fieldAttr.ColumnType));
}
static void WriteType(TextWriter w, SchemaColumn col)
{
w.Write(":");
w.Write(col.DbType.ToString());
if (HasLength(col.DbType))
{
w.Write("[");
w.Write(col.ColumnSize?.ToString() ?? "*");
w.Write("]");
}
if (col.AllowDBNull != false)
{
w.Write("?");
}
}
private static object SerializeBinaryObject(SchemaTable schemaTable, SchemaColumn schemaColumn, object value)
{
try
{
value = ProtoBufUtils.Serialize(value);
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} column:\"{0}\" serialize error:\r\n:{1}",
schemaTable.EntityName,
schemaColumn.Name,
ex);
return(null);
}
return(value);
}
internal string GetSqlType(SchemaColumn column)
{
if (column.IsIdentity)
{
return(this.IdentityType);
}
switch (column.DbType)
{
case DbType.String:
if (column.Size == -1)
{
return("text");
}
return("VARCHAR(" + column.Size + ") ");
case DbType.Int32:
return("INTEGER ");
case DbType.Int64:
return("BIGINT ");
case DbType.Decimal:
return("NUMERIC(" + column.Precision + "," + column.Scale + ") ");
case DbType.Double:
return("DOUBLE PRECISION ");
case DbType.Boolean:
return("BOOLEAN ");
case DbType.Date:
case DbType.DateTime:
return("TIMESTAMP ");
case DbType.Guid:
return("UUID ");
case DbType.Binary:
return("BYTEA ");
default:
return("!UNKNOWN VALUE TYPE!");
}
}
private static void CovertDataValue(SchemaColumn schemaColumn, ref object value)
{
if (value is DateTime && value.ToDateTime() < MathUtils.SqlMinDate)
{
value = MathUtils.SqlMinDate;
return;
}
//序列化Json
if (schemaColumn.IsSerialized)
{
if (schemaColumn.DbType == ColumnDbType.LongBlob || schemaColumn.DbType == ColumnDbType.Blob)
{
value = SerializeBinaryObject(value);
}
else
{
value = SerializeJson(schemaColumn, value);
}
}
}
// ---------------
private string BuildCreateColumn(SchemaColumn column)
{
var sb = new StringBuilder();
sb.Append(column.Name)
.Append(" ")
.Append(column.DbTypeNormalized);
if (column.PrimaryKey)
{
sb.Append(" IDENTITY(1,1)");
}
else
{
if (!string.IsNullOrEmpty(column.DefaultValueNormalizsed))
{
sb.Append(" DEFAULT (").Append(column.DefaultValueNormalizsed).Append(")");
}
}
sb.Append(column.Nullable ? " NULL" : " NOT NULL");
return(sb.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="column"></param>
/// <param name="value"></param>
protected virtual void SetPropertyValue(T entity, SchemaColumn column, object value)
{
object fieldValue;
if (column.IsSerialized)
{
//指定序列化方式
if (column.DbType == ColumnDbType.LongBlob ||
column.DbType == ColumnDbType.Blob)
{
fieldValue = ProtoBufUtils.Deserialize(value as byte[], column.ColumnType);
}
else
{
fieldValue = DeserializeJsonObject(value, column);
}
}
else
{
fieldValue = AbstractEntity.ParseValueType(value, column.ColumnType);
}
ObjectAccessor.Create(entity)[column.Name] = fieldValue;
}
private static object SerializeJson(SchemaTable schemaTable, SchemaColumn schemaColumn, object value)
{
try
{
value = value ?? string.Empty;
if (!string.IsNullOrEmpty(schemaColumn.JsonDateTimeFormat))
{
value = JsonUtils.SerializeCustom(value);
}
else
{
value = JsonUtils.Serialize(value);
}
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} column:\"{0}\" json serialize error:\r\n:{1}",
schemaTable.EntityName,
schemaColumn.Name,
ex);
return(null);
}
return(value);
}
private static void PushChildStack(MessageStructure parent, SchemaColumn parentColumn, object value)
{
if (parentColumn.IsDictionary)
{
var column = parentColumn.Children[1];
dynamic dict = value;
dynamic keys = dict.Keys;
int count = dict.Count;
parent.PushIntoStack(count);
foreach (var key in keys)
{
object item = dict[key];
var itemWriter = new MessageStructure();
itemWriter.PushIntoStack(key);
if (EntitySchemaSet.IsSupportType(column.ColumnType))
{
itemWriter.PushIntoStack(column.ColumnType, item);
}
else if (column.HasChild)
{
PushChildStack(itemWriter, column, item);
}
parent.PushIntoStack(itemWriter);
}
}
else if (parentColumn.IsList)
{
var column = parentColumn.Children[0];
dynamic list = value;
int count = list.Count;
parent.PushIntoStack(count);
foreach (var item in list)
{
var itemWriter = new MessageStructure();
if (EntitySchemaSet.IsSupportType(column.ColumnType))
{
itemWriter.PushIntoStack(column.ColumnType, item);
}
else if (column.HasChild)
{
PushChildStack(itemWriter, column, item);
}
parent.PushIntoStack(itemWriter);
}
}
else
{
//child entity object
parent.PushIntoStack(1);
var typeAccessor = ObjectAccessor.Create(value, true);
var itemWriter = new MessageStructure();
foreach (var column in parentColumn.Children)
{
try
{
var fieldValue = typeAccessor[column.Name];
if (EntitySchemaSet.IsSupportType(column.ColumnType))
{
itemWriter.PushIntoStack(column.ColumnType, fieldValue);
}
else if (column.HasChild)
{
PushChildStack(itemWriter, column, fieldValue);
}
}
catch
{
}
}
parent.PushIntoStack(itemWriter);
}
}
protected void OnSetProperty(MemoryData entity, SchemaColumn column, object value)
{
ObjectAccessor.Create(entity)[column.Name] = value;
}
protected override object GetPropertyValue(MemoryData entity, SchemaColumn column)
{
return(ObjectAccessor.Create(entity)[column.Name]);
}
public virtual void Insert(object o)
{
if (o != null)
{
SchemaTable t = Schema.EnsureSchema(o.GetType());
if (t != null)
{
SQInsertQuery q = new SQInsertQuery()
{
Table = new SQAliasableObject(t.Table.Name),
ReturnID = t.GetPrimaryKeyColumn() != null && t.GetPrimaryKeyColumn().Column.IsIdentity
};
PopulateSetQuery(q, o, t);
SQSelectResult sr = Adp.Insert(q);
try
{
if (q.ReturnID)
{
if (sr.Reader.Read())
{
SchemaColumn pkCol = t.GetPrimaryKeyColumn();
object id = sr.Reader.GetValue(0);
if (id.GetType() != pkCol.Property.PropertyType)
{
switch (pkCol.Column.DataType)
{
case SQDataTypes.Int16:
id = Convert.ToInt16(id);
break;
case SQDataTypes.Int32:
id = Convert.ToInt32(id);
break;
case SQDataTypes.Int64:
id = Convert.ToInt64(id);
break;
case SQDataTypes.Decimal:
id = Convert.ToDecimal(id);
break;
}
}
if (o is IPopulateProperties)
{
((IPopulateProperties)o).PopulateProperty(pkCol.Property.Name, id);
}
else
{
pkCol.Property.SetValue(o, id, null);
}
}
}
}
finally
{
sr.Close();
}
}
else
{
throw new InvalidTypeException(o.GetType());
}
}
}
/// <summary>
///
/// </summary>
/// <param name="entity"></param>
/// <param name="column"></param>
/// <returns></returns>
protected virtual object GetPropertyValue(T entity, SchemaColumn column)
{
return(ObjectAccessor.Create(entity)[column.Name]);
}
private object DeserializeBinaryObject(SchemaTable schemaTable, AbstractEntity entity, object value, SchemaColumn fieldAttr, string columnName)
{
try
{
if (value is byte[])
{
byte[] buffer = value as byte[];
return(ProtoBufUtils.Deserialize(buffer, fieldAttr.ColumnType));
}
throw new Exception("value is not byte[] type.");
}
catch (Exception ex)
{
TraceLog.WriteError("Table:{0} key:{1} column:{2} deserialize binary error:byte[] to {3}\r\nException:{4}",
schemaTable.EntityName,
entity.GetKeyCode(),
columnName,
fieldAttr.ColumnType.FullName,
ex);
}
return(null);
}
