private static String GetPrimitiveValString(PrimitiveVal v)
{
if (v.OnBooleanValue)
{
return(v.BooleanValue.ToInvariantString());
}
else if (v.OnStringValue)
{
return(v.StringValue);
}
else if (v.OnIntValue)
{
return(v.IntValue.ToInvariantString());
}
else if (v.OnRealValue)
{
return(v.RealValue.ToInvariantString());
}
else if (v.OnBinaryValue)
{
var ByteString = String.Join(" ", v.BinaryValue.Select(b => b.ToString("X2", System.Globalization.CultureInfo.InvariantCulture)).ToArray());
return(ByteString);
}
else if (v.OnInt64Value)
{
return(v.Int64Value.ToInvariantString());
}
else
{
throw new InvalidOperationException();
}
}
private static PrimitiveVal GetDefaultValue(TypeRef r)
{
if (r == "Boolean")
{
return(PrimitiveVal.CreateBooleanValue(false));
}
else if (r == "String")
{
return(PrimitiveVal.CreateStringValue(""));
}
else if (r == "Int")
{
return(PrimitiveVal.CreateIntValue(0));
}
else if (r == "Real")
{
return(PrimitiveVal.CreateRealValue(0));
}
else if (r == "Binary")
{
return(PrimitiveVal.CreateBinaryValue(new List <Byte> {
}));
}
else if (r == "Int64")
{
return(PrimitiveVal.CreateInt64Value(0));
}
else
{
throw new InvalidOperationException();
}
}
private static Func <PrimitiveVal, PrimitiveVal> GetPrimitiveTranslator(TypeRef OldType, TypeRef NewType)
{
if (OldType.Value == NewType.Value)
{
return(v => v);
}
if (OldType.Value == "Boolean")
{
if (NewType.Value == "String")
{
return(v =>
{
if (!v.OnBooleanValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateStringValue(v.BooleanValue ? "True" : "False");
});
}
else if (NewType.Value == "Int")
{
return(v =>
{
if (!v.OnBooleanValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateIntValue(v.BooleanValue ? -1 : 0);
});
}
else if (NewType.Value == "Real")
{
return(v =>
{
if (!v.OnBooleanValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateRealValue(v.BooleanValue ? -1 : 0);
});
}
else if (NewType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
else if (NewType.Value == "Int64")
{
return(v =>
{
if (!v.OnBooleanValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateInt64Value(v.BooleanValue ? -1 : 0);
});
}
}
else if (OldType.Value == "String")
{
if (NewType.Value == "Boolean")
{
return(v =>
{
if (!v.OnStringValue)
{
throw new InvalidOperationException();
}
;
var b = false;
if (v.StringValue == "True")
{
b = true;
}
else if (v.StringValue == "False")
{
b = false;
}
return PrimitiveVal.CreateBooleanValue(b);
});
}
else if (NewType.Value == "Int")
{
return(v =>
{
if (!v.OnStringValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateIntValue(NumericStrings.InvariantParseInt32(v.StringValue));
});
}
else if (NewType.Value == "Real")
{
return(v =>
{
if (!v.OnStringValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateRealValue(NumericStrings.InvariantParseFloat64(v.StringValue));
});
}
else if (NewType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
else if (NewType.Value == "Int64")
{
return(v =>
{
if (!v.OnStringValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateInt64Value(NumericStrings.InvariantParseInt64(v.StringValue));
});
}
}
else if (OldType.Value == "Int")
{
if (NewType.Value == "Boolean")
{
return(v =>
{
if (!v.OnIntValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateBooleanValue(v.IntValue != 0);
});
}
else if (NewType.Value == "String")
{
return(v =>
{
if (!v.OnIntValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateStringValue(v.IntValue.ToInvariantString());
});
}
else if (NewType.Value == "Real")
{
return(v =>
{
if (!v.OnIntValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateRealValue(v.IntValue);
});
}
else if (NewType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
else if (NewType.Value == "Int64")
{
return(v =>
{
if (!v.OnIntValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateInt64Value(v.IntValue);
});
}
}
else if (OldType.Value == "Real")
{
if (NewType.Value == "Boolean")
{
return(v =>
{
if (!v.OnRealValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateBooleanValue(v.RealValue != 0.0);
});
}
else if (NewType.Value == "String")
{
return(v =>
{
if (!v.OnRealValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateStringValue(v.RealValue.ToInvariantString());
});
}
else if (NewType.Value == "Int")
{
return(v =>
{
if (!v.OnRealValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateIntValue(Convert.ToInt32(v.RealValue));
});
}
else if (NewType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
else if (NewType.Value == "Int64")
{
return(v =>
{
if (!v.OnRealValue)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateInt64Value(Convert.ToInt64(v.RealValue));
});
}
}
else if (OldType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
else if (OldType.Value == "Int64")
{
if (NewType.Value == "Boolean")
{
return(v =>
{
if (!v.OnInt64Value)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateBooleanValue(v.Int64Value != 0);
});
}
else if (NewType.Value == "String")
{
return(v =>
{
if (!v.OnInt64Value)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateStringValue(v.Int64Value.ToInvariantString());
});
}
else if (NewType.Value == "Int")
{
return(v =>
{
if (!v.OnInt64Value)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateIntValue((int)(v.Int64Value));
});
}
else if (NewType.Value == "Real")
{
return(v =>
{
if (!v.OnInt64Value)
{
throw new InvalidOperationException();
}
;
return PrimitiveVal.CreateRealValue(v.Int64Value);
});
}
else if (NewType.Value == "Binary")
{
return(v => { throw new InvalidOperationException(); });
}
}
throw new InvalidOperationException();
}
public static TableVal ExportTable(Dictionary <String, EntityDef> EntityMetas, Dictionary <String, String> EnumUnderlyingTypes, IDbConnection c, IDbTransaction b, String EntityName, DatabaseType Type)
{
Func <String, String> Escape;
if (Type == DatabaseType.SqlServer)
{
Escape = s => "[" + s + "]";
}
else if (Type == DatabaseType.PostgreSQL)
{
Escape = s => "\"" + s.ToLowerInvariant() + "\"";
}
else if (Type == DatabaseType.MySQL)
{
Escape = s => "`" + s + "`";
}
else
{
throw new InvalidOperationException();
}
var Meta = EntityMetas[EntityName];
var CollectionName = Meta.CollectionName;
var Values = new List <RowVal>();
var Columns = Meta.Fields.Where(f => f.Attribute.OnColumn).ToList();
var ColumnStr = String.Join(", ", Columns.Select(col => Escape(col.Name)));
var cmd = c.CreateCommand();
cmd.Transaction = b;
cmd.CommandText = String.Format("SELECT {1} FROM {0}", Escape(CollectionName), ColumnStr);
cmd.CommandType = CommandType.Text;
using (var dr = cmd.ExecuteReader())
{
var RowIndex = 0;
while (dr.Read())
{
var vColumns = new List <ColumnVal>();
foreach (var f in Columns)
{
ColumnVal cv;
String TypeName;
Boolean IsOptional;
if (f.Type.OnTypeRef)
{
TypeName = f.Type.TypeRef.Value;
IsOptional = false;
}
else if (f.Type.OnOptional)
{
TypeName = f.Type.Optional.Value;
IsOptional = true;
}
else
{
throw new InvalidOperationException(String.Format("InvalidType: {0}.{1}", CollectionName, f.Name));
}
if (EnumUnderlyingTypes.ContainsKey(TypeName))
{
TypeName = EnumUnderlyingTypes[TypeName];
}
try
{
if (TypeName.Equals("Boolean", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
if (IsOptional)
{
var v = dr.GetValue(o);
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateBooleanValue(dr.GetBoolean(o)));
}
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateBooleanValue(dr.GetBoolean(o)));
}
}
else if (TypeName.Equals("String", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
var v = dr.GetValue(o);
if (IsOptional)
{
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateStringValue(dr.GetString(o)));
}
}
else
{
if (v == DBNull.Value)
{
throw new InvalidOperationException();
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateStringValue(dr.GetString(o)));
}
}
}
else if (TypeName.Equals("Int", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
if (IsOptional)
{
var v = dr.GetValue(o);
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateIntValue(dr.GetInt32(o)));
}
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateIntValue(dr.GetInt32(o)));
}
}
else if (TypeName.Equals("Int64", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
if (IsOptional)
{
var v = dr.GetValue(o);
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateInt64Value(dr.GetInt64(o)));
}
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateInt64Value(dr.GetInt64(o)));
}
}
else if (TypeName.Equals("Real", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
if (IsOptional)
{
var v = dr.GetValue(o);
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateRealValue(dr.GetFloat(o)));
}
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateRealValue(dr.GetFloat(o)));
}
}
else if (TypeName.Equals("Binary", StringComparison.OrdinalIgnoreCase))
{
var o = dr.GetOrdinal(f.Name);
var v = dr.GetValue(o);
if (IsOptional)
{
if (v == DBNull.Value)
{
cv = ColumnVal.CreateOptional(Optional <PrimitiveVal> .Empty);
}
else
{
cv = ColumnVal.CreateOptional(PrimitiveVal.CreateBinaryValue(new List <Byte>((Byte[])(v))));
}
}
else
{
if (v == DBNull.Value)
{
throw new InvalidOperationException();
}
else
{
cv = ColumnVal.CreatePrimitive(PrimitiveVal.CreateBinaryValue(new List <Byte>((Byte[])(v))));
}
}
}
else
{
throw new InvalidOperationException(String.Format("InvalidType: {0}.{1}", CollectionName, f.Name));
}
}
catch (Exception e)
{
throw new InvalidOperationException(String.Format("InvalidValue: {0}[{2}].{1}", CollectionName, f.Name, RowIndex), e);
}
vColumns.Add(cv);
}
Values.Add(new RowVal {
Columns = vColumns
});
RowIndex += 1;
}
}
return(new TableVal {
Rows = Values
});
}
