protected override Expression VisitConstantExpression(ConstantExpression expression)
{
var value = expression.Value;
if (value != null)
{
var type = value.GetType();
var source = SqlSourceAttribute.FindSource(type);
var converter = QueryParts.ConverterFactory.GetSerializationFactory(type);
if (converter != null)
{
SqlExpression.Append('\'').Append(converter(value).Replace("'", "''")).Append('\'');
if (value is IIdentifiable || value is IEntity)
{
SqlExpression.Append("::").Append(source);
}
else if (value is ICloneable)
{
SqlExpression.Append("::\"").Append(type.Namespace).Append("\".\"").Append(type.Name).Append('"');
}
return(expression);
}
else if (type.IsEnum)
{
SqlExpression.Append('\'').Append(value).Append("'::\"").Append(type.Namespace).Append("\".\"").Append(type.Name).Append('"');
return(expression);
}
}
SqlExpression.Append(TypeConverter.Convert(expression.Type, expression.Value));
return(expression);
}
public string FormatArray(object[] values)
{
if (values == null || values.Length == 0)
{
throw new FrameworkException("Array must have elements!");
}
var element = values[0].GetType();
var converter = ConverterFactory.GetSerializationFactory(element);
if (converter != null)
{
var source =
SqlSourceAttribute.FindSource(element)
?? "\"" + element.Namespace + "\".\"" + element.Name + "\"";
var arr = Postgres.PostgresTypedArray.ToArray(values, converter);
return(arr + "::" + source + "[]");
}
if (NpgsqlTypes.TypeConverter.CanConvert(element))
{
var val =
Postgres.PostgresTypedArray.ToArray(
values,
v => NpgsqlTypes.TypeConverter.Convert(element, v));
var name = NpgsqlTypes.TypeConverter.GetTypeName(element);
return(val + "::" + name + "[]");
}
throw new NotSupportedException("Don't know how to convert array!");
}
private static string FromSqlSource(string name, Type type)
{
var source = SqlSourceAttribute.FindSource(type);
if (!string.IsNullOrEmpty(source))
{
return("{0} as \"{1}\"".With(source, name));
}
throw new NotSupportedException(@"Unknown sql source {0}!
Add {1} attribute or {2} or {3} or {4} interface".With(
type.FullName,
typeof(SqlSourceAttribute).FullName,
typeof(IAggregateRoot).FullName,
typeof(IIdentifiable).FullName,
typeof(IEntity).FullName));
}
private string FormatStringValues(string name, Type type, object[] array)
{
Type element = null;
if (type.IsGenericType || type.IsArray)
{
element = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
var converter = ConverterFactory.GetSerializationFactory(element);
if (converter != null)
{
var source = SqlSourceAttribute.FindSource(element)
?? "\"" + element.Namespace + "\".\"" + element.Name + "\"";
var arr = Postgres.PostgresTypedArray.ToArray(array, converter);
return(@"(SELECT ""{2}"" FROM unnest({0}::{1}[]) ""{2}"") ""{2}""".With(
arr,
source,
name));
}
else if (!NpgsqlTypes.TypeConverter.CanConvert(element))
{
var fields = element.GetFields().Select(it => new ColumnValue(it));
var properties = element.GetProperties().Select(it => new ColumnValue(it));
var columns = fields.Union(properties).ToList();
return("(SELECT "
+ string.Join(", ", columns.Select((it, ind) => "column{0} AS \"{1}\"".With(ind + 1, it.Name)))
+ " FROM (VALUES"
+ string.Join(
", ",
array.Select(it => "(" + string.Join(", ", columns.Select(c => c.GetBackendValue(it))) + ")"))
+ ") _sq1 ) \"" + name + "\"");
}
}
var formated = (from i in array select FormatObject(i)).ToList();
var typeAlias = element != null && NpgsqlTypes.TypeConverter.CanConvert(element)
? "::" + NpgsqlTypes.TypeConverter.GetTypeName(element)
: string.Empty;
return
("(SELECT {0}{1} AS \"{2}\"{3}) AS \"{2}\"".With(
formated[0],
typeAlias,
name,
string.Concat(formated.Skip(1).Select(it => " UNION ALL SELECT " + it))));
}
public string FormatObject(object value)
{
if (value == null)
{
return("NULL");
}
var type = value.GetType();
var serialization = ConverterFactory.GetSerializationFactory(type);
if (serialization != null)
{
///TODO use BuildTuple with quote method
var result = "('" + serialization(value).Replace("'", "''") + "'::";
string source = null;
if (value is IIdentifiable || value is IEntity)
{
source = SqlSourceAttribute.FindSource(type);
}
else if (value is ICloneable)
{
source = "\"" + type.Namespace + "\".\"" + type.Name + "\"";
}
if (source == null)
{
throw new FrameworkException("Can't find source for " + type.FullName);
}
return(result + source + ").*");
}
else if (type.IsEnum)
{
return("'" + value + "'::\"" + type.Namespace + "\".\"" + type.Name + "\"");
}
if (NpgsqlTypes.TypeConverter.CanConvert(type))
{
var val = NpgsqlTypes.TypeConverter.Convert(type, value);
var name = NpgsqlTypes.TypeConverter.GetTypeName(type);
return(val + "::" + name);
}
//TODO probably wrong. better to throw an exception!?
return(value.ToString());
}
