private byte[] ConvertToBackendPlainQuery(Object NativeData, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if ((NativeData == DBNull.Value) || (NativeData == null))
{
return(ASCIIByteArrays.NULL); // Plain queries exptects null values as string NULL.
}
if (_ConvertNativeToBackendText != null)
{
byte[] backendSerialization;
// This path is responsible for escaping, and may also add quoting and the E prefix.
backendSerialization = (_ConvertNativeToBackendText(this, NativeData, false, options, arrayElement));
if (Quote)
{
backendSerialization = QuoteASCIIString(backendSerialization, false, arrayElement);
}
return(backendSerialization);
}
else if (NativeData is Enum)
{
byte[] backendSerialization;
// Do a special handling of Enum values.
// Translate enum value to its underlying type.
backendSerialization =
BackendEncoding.UTF8Encoding.GetBytes(
(String)Convert.ChangeType(
Enum.Format(NativeData.GetType(), NativeData, "d"),
typeof(String), CultureInfo.InvariantCulture
)
);
backendSerialization = QuoteASCIIString(backendSerialization, false, arrayElement);
return(backendSerialization);
}
else
{
byte[] backendSerialization;
if (NativeData is IFormattable)
{
backendSerialization = BackendEncoding.UTF8Encoding.GetBytes(((IFormattable)NativeData).ToString(null, ni));
}
else
{
backendSerialization = BackendEncoding.UTF8Encoding.GetBytes(NativeData.ToString());
}
if (Quote)
{
backendSerialization = QuoteASCIIString(backendSerialization, false, arrayElement);
}
return(backendSerialization);
}
}
private byte[] ConvertToBackendExtendedQuery(Object NativeData, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if ((NativeData == DBNull.Value) || (NativeData == null))
{
return(null); // Extended query expects null values be represented as null.
}
if (!NpgsqlTypesHelper.SuppressBinaryBackendEncoding && _ConvertNativeToBackendBinary != null)
{
return(_ConvertNativeToBackendBinary(this, NativeData, options));
}
else if (_ConvertNativeToBackendText != null)
{
byte[] backendSerialization;
backendSerialization = _ConvertNativeToBackendText(this, NativeData, true, options, arrayElement);
if (Quote)
{
backendSerialization = QuoteASCIIString(backendSerialization, true, arrayElement);
}
return(backendSerialization);
}
else
{
byte[] backendSerialization;
if (NativeData is Enum)
{
// Do a special handling of Enum values.
// Translate enum value to its underlying type.
backendSerialization = BackendEncoding.UTF8Encoding.GetBytes((String)
Convert.ChangeType(Enum.Format(NativeData.GetType(), NativeData, "d"), typeof(String),
CultureInfo.InvariantCulture));
}
else if (NativeData is IFormattable)
{
backendSerialization = BackendEncoding.UTF8Encoding.GetBytes(((IFormattable)NativeData).ToString(null, ni));
}
else
{
backendSerialization = BackendEncoding.UTF8Encoding.GetBytes(NativeData.ToString());
}
if (Quote)
{
backendSerialization = QuoteASCIIString(backendSerialization, true, arrayElement);
}
return(backendSerialization);
}
}
/// <summary>
/// Perform a data conversion from a native object to
/// a backend representation.
/// DBNull and null values are handled differently depending if a plain query is used
/// When
/// </summary>
/// <param name="NativeData">Native .NET object to be converted.</param>
/// <param name="forExtendedQuery">Specifies that the value should be formatted for the extended query syntax.</param>
/// <param name="options">Options to guide serialization. If null, a default options set is used.</param>
/// <param name="arrayElement">Specifies that the value should be formatted as an extended query array element.</param>
public byte[] ConvertToBackend(Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options = null, bool arrayElement = false)
{
if (options == null)
{
options = NativeToBackendTypeConverterOptions.Default;
}
if (forExtendedQuery)
{
return(ConvertToBackendExtendedQuery(NativeData, options, arrayElement));
}
else
{
return(ConvertToBackendPlainQuery(NativeData, options, arrayElement));
}
}
/// <summary>
/// Serialise the enumeration or array.
/// </summary>
public byte[] ArrayToArrayText(NpgsqlNativeTypeInfo TypeInfo, object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
MemoryStream array = new MemoryStream();
if (!forExtendedQuery)
{
if (!options.UseConformantStrings && options.Supports_E_StringPrefix)
{
array.WriteByte((byte)ASCIIBytes.E);
}
array.WriteByte((byte)ASCIIBytes.SingleQuote);
}
if (!WriteItemText(TypeInfo, NativeData, array, forExtendedQuery, options))
{
array.Write(ASCIIArrayByteArrays.EmptyArray, 0, ASCIIArrayByteArrays.EmptyArray.Length);
}
if (!forExtendedQuery)
{
array.WriteByte((byte)ASCIIBytes.SingleQuote);
}
return(array.ToArray());
}
internal static byte[] ToTimeTZ(NpgsqlNativeTypeInfo typeInfo, object nativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (nativeData is DateTime)
{
return(BasicNativeToBackendTypeConverter.ToTime(typeInfo, nativeData, forExtendedQuery, options, arrayElement));
}
NpgsqlTimeTZ time;
if (nativeData is TimeSpan)
{
time = (NpgsqlTimeTZ)(TimeSpan)nativeData;
}
else
{
time = (NpgsqlTimeTZ)nativeData;
}
return(BackendEncoding.UTF8Encoding.GetBytes(time.ToString()));
}
/// <summary>
/// Convert to a postgres inet.
/// </summary>
internal static byte[] ToIPAddress(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (NativeData is NpgsqlInet)
{
return(BackendEncoding.UTF8Encoding.GetBytes(((NpgsqlInet)NativeData).ToString()));
}
return(BackendEncoding.UTF8Encoding.GetBytes(NativeData.ToString()));
}
/// <summary>
/// Polygon.
/// </summary>
internal static byte[] ToPolygon(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
StringBuilder B = new StringBuilder();
foreach (NpgsqlPoint P in ((NpgsqlPolygon)NativeData))
{
B.AppendFormat(CultureInfo.InvariantCulture, "{0}({1},{2})", (B.Length > 0 ? "," : ""), P.X, P.Y);
}
return(BackendEncoding.UTF8Encoding.GetBytes(String.Format("({0})", B)));
}
/// <summary>
/// Box.
/// </summary>
internal static byte[] ToBox(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
/*if (NativeData.GetType() == typeof(Rectangle)) {
* Rectangle R = (Rectangle)NativeData;
* return String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", R.Left, R.Top, R.Left + R.Width, R.Top + R.Height);
* } else if (NativeData.GetType() == typeof(RectangleF)) {
* RectangleF R = (RectangleF)NativeData;
* return String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", R.Left, R.Top, R.Left + R.Width, R.Top + R.Height);*/
if (NativeData is NpgsqlBox)
{
NpgsqlBox box = (NpgsqlBox)NativeData;
return
(BackendEncoding.UTF8Encoding.GetBytes(String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", box.LowerLeft.X, box.LowerLeft.Y,
box.UpperRight.X, box.UpperRight.Y)));
}
else
{
throw new InvalidCastException("Unable to cast data to Rectangle type");
}
}
/// <summary>
/// Convert a System.Double to a postgres float8.
/// </summary>
internal static byte[] DoubleToFloat8Binary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, NativeToBackendTypeConverterOptions options)
{
return(PGUtil.HostNetworkByteOrderSwap(BitConverter.GetBytes(Convert.ToDouble(NativeData))));
}
internal static byte[] ToBasicType <T>(NpgsqlNativeTypeInfo TypeInfo, object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
// This double cast is needed in order to get the enum type handled correctly (IConvertible)
// and the decimal separator always as "." regardless of culture (IFormattable)
return(BackendEncoding.UTF8Encoding.GetBytes((((IFormattable)((IConvertible)NativeData).ToType(typeof(T), null)).ToString(null, CultureInfo.InvariantCulture.NumberFormat))));
}
/// <summary>
/// Convert a string to UTF8 encoded text.
/// </summary>
internal static byte[] StringToTextBinary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, NativeToBackendTypeConverterOptions options)
{
return(BackendEncoding.UTF8Encoding.GetBytes(NativeData.ToString()));
}
/// <summary>
/// Convert a string to UTF8 encoded text, escaped and quoted as required.
/// </summary>
internal static byte[] StringToTextText(NpgsqlNativeTypeInfo TypeInfo, Object oNativeData, bool forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
string NativeData = oNativeData.ToString();
StringEncodingInfo encodingInfo;
// Using a four bit hash key derived from the options at hand,
// find the correct string encoding info object.
encodingInfo = stringEncodingInfoTable[
StringEncodingInfoHash(
forExtendedQuery,
options.UseConformantStrings,
options.Supports_E_StringPrefix,
arrayElement
)
];
if (encodingInfo.Quote == 0)
{
// No quoting or escaping needed.
return(BackendEncoding.UTF8Encoding.GetBytes(NativeData));
}
// Give the output string builder enough room to start for the string, quotes, E-prefix,
// and 1 in 10 characters needing to be escaped; a WAG.
StringBuilder retQuotedEscaped = new StringBuilder(NativeData.Length + 3 + NativeData.Length / 10);
if (encodingInfo.UseEPrefix)
{
retQuotedEscaped.Append('E');
}
retQuotedEscaped.Append((char)encodingInfo.Quote);
// Escape the string using the escape characters from the lookup.
foreach (char ch in NativeData)
{
switch (ch)
{
case '\'':
retQuotedEscaped.Append(encodingInfo.SingleQuoteEscape);
break;
case '\"':
retQuotedEscaped.Append(encodingInfo.DoubleQuoteEscape);
break;
case '\\':
retQuotedEscaped.Append(encodingInfo.BackSlashEscape);
break;
}
retQuotedEscaped.Append(ch);
}
retQuotedEscaped.Append((char)encodingInfo.Quote);
return(BackendEncoding.UTF8Encoding.GetBytes(retQuotedEscaped.ToString()));
}
static NativeToBackendTypeConverterOptions()
{
_default = new NativeToBackendTypeConverterOptions(true, false, true, false, null);
}
private bool WriteItemText(NpgsqlNativeTypeInfo TypeInfo, object item, MemoryStream array, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options)
{
//item could be:
//an Ienumerable - in which case we call WriteEnumeration
//an element - in which case we call the NpgsqlNativeTypeInfo for that type to serialise it.
//an array - in which case we call WriteArray,
// Even an string being an IEnumerable, it shouldn't be processed. It will be processed on the last else.
// See http://pgfoundry.org/tracker/?func=detail&atid=592&aid=1010514&group_id=1000140 for more info.
if (item == null || NpgsqlTypesHelper.DefinedType(item))
{
byte[] element;
element = _elementConverter.ConvertToBackend(item, forExtendedQuery, options, true);
array.Write(element, 0, element.Length);
return(true);
}
else if (item is Array)
{
return(WriteArrayText(TypeInfo, item as Array, array, forExtendedQuery, options));
}
else if (item is IEnumerable)
{
return(WriteEnumeration(TypeInfo, item as IEnumerable, array, forExtendedQuery, options));
}
else
{//This shouldn't really be reachable.
byte[] element;
element = _elementConverter.ConvertToBackend(item, forExtendedQuery, options, true);
array.Write(element, 0, element.Length);
return(true);
}
}
/// <summary>
/// Convert to a postgresql time.
/// </summary>
internal static byte[] ToTime(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (!(NativeData is DateTime))
{
return(ExtendedNativeToBackendTypeConverter.ToTime(TypeInfo, NativeData, forExtendedQuery, options, arrayElement));
}
else
{
return(BackendEncoding.UTF8Encoding.GetBytes(((DateTime)NativeData).ToString("HH:mm:ss.ffffff", DateTimeFormatInfo.InvariantInfo)));
}
}
/// <summary>
/// Binary data, escaped and quoted as required.
/// </summary>
internal static byte[] ByteArrayToByteaText(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, bool forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
StringEncodingInfo encodingInfo;
// Using a four bit hash key derived from the options at hand,
// find the correct string encoding info object.
encodingInfo = stringEncodingInfoTable[
StringEncodingInfoHash(
forExtendedQuery,
options.UseConformantStrings,
options.Supports_E_StringPrefix,
arrayElement
)
];
if (!options.SupportsHexByteFormat)
{
return(ByteArrayToByteaTextEscaped((byte[])NativeData, encodingInfo));
}
else
{
return(ByteArrayToByteaTextHexFormat((byte[])NativeData, encodingInfo));
}
}
/// <summary>
/// Convert to a postgres money.
/// </summary>
internal static byte[] ToMoney(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
//Formats accepted vary according to locale, but it always accepts a plain number (no currency or
//grouping symbols) passed as a string (with the appropriate cast appended, as UseCast will cause
//to happen.
return(BackendEncoding.UTF8Encoding.GetBytes(((IFormattable)NativeData).ToString(null, CultureInfo.InvariantCulture.NumberFormat)));
}
/// <summary>
/// Binary data, raw.
/// </summary>
internal static byte[] ByteArrayToByteaBinary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, NativeToBackendTypeConverterOptions options)
{
return((byte[])NativeData);
}
internal static byte[] DoubleToFloat8Text(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
//Formats accepted vary according to locale, but it always accepts a plain number (no currency or
//grouping symbols) passed as a string (with the appropriate cast appended, as UseCast will cause
//to happen.
if (!arrayElement)
{
var asDouble = (double)NativeData;
if (double.IsNaN(asDouble))
{
return(ASCIIByteArrays.NAN_QUOTED);
}
if (double.IsPositiveInfinity(asDouble))
{
return(ASCIIByteArrays.INFINITY_QUOTED);
}
if (double.IsNegativeInfinity(asDouble))
{
return(ASCIIByteArrays.NEG_INFINITY_QUOTED);
}
}
return(BackendEncoding.UTF8Encoding.GetBytes(((IFormattable)NativeData).ToString("R", CultureInfo.InvariantCulture.NumberFormat)));
}
/// <summary>
/// Convert to a postgresql boolean text format.
/// </summary>
internal static byte[] BooleanToBooleanText(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
return(((bool)NativeData) ? ASCIIByteArrays.TRUE : ASCIIByteArrays.FALSE);
}
/// <summary>
/// Point.
/// </summary>
internal static byte[] ToPoint(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (NativeData is NpgsqlPoint)
{
NpgsqlPoint P = (NpgsqlPoint)NativeData;
return(BackendEncoding.UTF8Encoding.GetBytes(String.Format(CultureInfo.InvariantCulture, "({0},{1})", P.X, P.Y)));
}
else
{
throw new InvalidCastException("Unable to cast data to NpgsqlPoint type");
}
}
/// <summary>
/// Convert to a postgresql boolean binary format.
/// </summary>
internal static byte[] BooleanToBooleanBinary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, NativeToBackendTypeConverterOptions options)
{
return(((bool)NativeData) ? ASCIIByteArrays.Byte_1 : ASCIIByteArrays.Byte_0);
}
/// <summary>
/// LSeg.
/// </summary>
internal static byte[] ToLSeg(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
NpgsqlLSeg S = (NpgsqlLSeg)NativeData;
return(BackendEncoding.UTF8Encoding.GetBytes(String.Format(CultureInfo.InvariantCulture, "{0},{1},{2},{3}", S.Start.X, S.Start.Y, S.End.X, S.End.Y)));
}
/// <summary>
/// Convert to a postgresql binary int8.
/// </summary>
internal static byte[] Int64ToInt8Binary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, NativeToBackendTypeConverterOptions options)
{
return(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(Convert.ToInt64(NativeData))));
}
/// <summary>
/// Circle.
/// </summary>
internal static byte[] ToCircle(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
NpgsqlCircle C = (NpgsqlCircle)NativeData;
return(BackendEncoding.UTF8Encoding.GetBytes(String.Format(CultureInfo.InvariantCulture, "{0},{1},{2}", C.Center.X, C.Center.Y, C.Radius)));
}
/// <summary>
/// Convert to a postgresql bit.
/// </summary>
internal static byte[] ToBit(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (NativeData is bool)
{
return(((bool)NativeData) ? ASCIIByteArrays.AsciiDigit_1 : ASCIIByteArrays.AsciiDigit_0);
}
// It may seem more sensible to just convert an integer to a BitString here and pass it on.
// However behaviour varies in terms of how this is interpretted if being passed to a bitstring
// value smaller than the int.
// Prior to Postgres 8.0, the behaviour would be the same either way. E.g. if 10 were passed to
// a bit(1) then the bits (1010) would be extracted from the left, so resulting in the bitstring B'1'.
// From 8.0 onwards though, if we cast 10 straight to a bit(1) then the right-most bit is taken,
// resulting in B'0'. If we cast it to the "natural" bitstring for it's size first (which is what would
// happen if we did that work here) then it would become B'1010' which would then be cast to bit(1) by
// taking the left-most bit resulting in B'1' (the behaviour one would expect from Postgres 7.x).
//
// Since we don't know what implicit casts (say by inserting into a table with a bitstring field of
// set size) may happen, we don't know how to ensure expected behaviour. While passing a bitstring
// literal would work as expected with Postgres before 8.0, it can fail with 8.0 and later.
else if (NativeData is int)
{
return(BackendEncoding.UTF8Encoding.GetBytes(NativeData.ToString()));
}
else
{
return(BackendEncoding.UTF8Encoding.GetBytes(((BitString)NativeData).ToString("E")));
}
}
/// <summary>
/// Convert to a postgres interval
/// </summary>
internal static byte[] ToInterval(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
return
(BackendEncoding.UTF8Encoding.GetBytes(((NativeData is TimeSpan)
? ((NpgsqlInterval)(TimeSpan)NativeData).ToString()
: ((NpgsqlInterval)NativeData).ToString())));
}
/// <summary>
/// Convert to a postgresql timestamp.
/// </summary>
internal static byte[] ToDateTime(NpgsqlNativeTypeInfo TypeInfo, Object NativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (!(NativeData is DateTime))
{
return(ExtendedNativeToBackendTypeConverter.ToTimeStamp(TypeInfo, NativeData, forExtendedQuery, options, arrayElement));
}
if (DateTime.MaxValue.Equals(NativeData))
{
return(ASCIIByteArrays.INFINITY);
}
if (DateTime.MinValue.Equals(NativeData))
{
return(ASCIIByteArrays.NEG_INFINITY);
}
return(BackendEncoding.UTF8Encoding.GetBytes((((DateTime)NativeData).ToString("yyyy-MM-dd HH:mm:ss.ffffff", DateTimeFormatInfo.InvariantInfo))));
}
internal static byte[] ToTimeStamp(NpgsqlNativeTypeInfo typeInfo, object nativeData, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options, bool arrayElement)
{
if (nativeData is DateTime)
{
return(BasicNativeToBackendTypeConverter.ToDateTime(typeInfo, nativeData, forExtendedQuery, options, arrayElement));
}
else
{
return(BackendEncoding.UTF8Encoding.GetBytes(nativeData.ToString()));
}
}
private bool WriteEnumeration(NpgsqlNativeTypeInfo TypeInfo, IEnumerable col, MemoryStream array, Boolean forExtendedQuery, NativeToBackendTypeConverterOptions options)
{
bool writtenSomething = false;
bool firstItem = true;
//write each item with a comma between them.
foreach (object item in col)
{
if (firstItem)
{
array.WriteByte((byte)ASCIIBytes.BraceCurlyLeft);
firstItem = false;
}
else
{
array.WriteByte((byte)ASCIIBytes.Comma);
}
writtenSomething |= WriteItemText(TypeInfo, item, array, forExtendedQuery, options);
}
if (writtenSomething)
{
array.WriteByte((byte)ASCIIBytes.BraceCurlyRight);
}
return(writtenSomething);
}