/// <summary>
/// Add the given NpgsqlBackendTypeInfo to this mapping.
/// </summary>
public void AddType(NpgsqlBackendTypeInfo T)
{
if (OIDIndex.ContainsKey(T.OID))
{
throw new Exception("Type already mapped");
}
OIDIndex[T.OID] = T;
NameIndex[T.Name] = T;
}
/// <summary>
/// Creates an array from pg representation.
/// </summary>
public object ToArray(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
{
//first create an arraylist, then convert it to an array.
return ToArray(ToArrayList(TypeInfo, BackendData, TypeSize, TypeModifier), _elementConverter.Type);
}
public bool TryGetValue(int oid, out NpgsqlBackendTypeInfo value)
{
return OIDIndex.TryGetValue(oid, out value);
}
/// <summary>
/// Creates an array from pg representation.
/// </summary>
public object ToArray(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
{
//first create an arraylist, then convert it to an array.
return(ToArray(ToArrayList(TypeInfo, BackendData, TypeSize, TypeModifier), _elementConverter.Type));
}
/// <summary>
/// Creates an array from pg text representation.
/// </summary>
public object ArrayTextToArray(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
//first create an arraylist, then convert it to an array.
ArrayList arrayList = ToArrayList(TypeInfo, BackendData, TypeSize, TypeModifier);
return ToArray(arrayList, _elementConverter.GetType(TypeModifier));
}
/// <summary>
/// Convert UTF8 encoded text a string.
/// </summary>
internal static Object TextBinaryToString(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return BackendEncoding.UTF8Encoding.GetString(BackendData);
}
/// <summary>
/// Polygon.
/// </summary>
internal static Object ToPolygon(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize,
Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
Match m = pathpolygonRegex.Match(BackendData);
List<NpgsqlPoint> points = new List<NpgsqlPoint>();
while (m.Success)
{
// Here we have to do a little hack, because as of 2004-08-11 mono cvs version, the last group is returned with
// a trailling ')' only when the last character of the string is a ')' which is the case for closed paths
// returned by backend. This gives parsing exception when converting to single.
// I still don't know if this is a bug in mono or in my regular expression.
// Check if there is this character and remove it.
String group2 = m.Groups[2].ToString();
if (group2.EndsWith(")"))
{
group2 = group2.Remove(group2.Length - 1, 1);
}
points.Add(
new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
Single.Parse(group2, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
m = m.NextMatch();
}
return new NpgsqlPolygon(points);
}
/// <summary>
/// Convert a postgresql date to a System.DateTime.
/// </summary>
internal static Object ToDate(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
// First check for special values infinity and -infinity.
if (ByteArrayEqual(bBackendData, ASCIIByteArrays.INFINITY))
{
return DateTime.MaxValue;
}
if (ByteArrayEqual(bBackendData, ASCIIByteArrays.NEG_INFINITY))
{
return DateTime.MinValue;
}
return
DateTime.ParseExact(BackendEncoding.UTF8Encoding.GetString(bBackendData), DateFormats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowWhiteSpaces);
}
/// <summary>
/// Creates an n-dimensional System.Array from PG binary representation.
/// This function reads the array header and sets up an n-dimensional System.Array object to hold its data.
/// PopulateArrayFromBinaryArray() is then called to carry out array population.
/// </summary>
public object ArrayBinaryToArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
// Sanity check.
if (BackendData.Length < 4)
{
throw new Exception("Insuffient backend data to describe dimension count in binary array header");
}
// Offset 0 holds an integer dscribing the number of dimensions in the array.
int nDims = PGUtil.ReadInt32(BackendData, 0);
// Sanity check.
if (nDims < 0)
{
throw new NpgsqlException("Invalid array dimension count encountered in binary array header");
}
// {PG handles 0-dimension arrays, but .net does not. Return a 0-size 1-dimensional array.
if (nDims == 0)
{
return(Array.CreateInstance(_elementConverter.FrameworkType, 0));
}
int dimOffset;
// Offset 12 begins an array of {int,int} objects, of length nDims.
int dataOffset = 12;
// Sanity check.
if (BackendData.Length < dataOffset + nDims * 8)
{
throw new NpgsqlException("Insuffient backend data to describe all expected dimensions in binary array header");
}
int[] dimLengths;
int[] dimLBounds;
dimLengths = new int[nDims];
dimLBounds = new int[nDims];
// Populate array dimension lengths and lower bounds.
for (dimOffset = 0; dimOffset < nDims; dimOffset++)
{
dimLengths[dimOffset] = PGUtil.ReadInt32(BackendData, dataOffset);
dataOffset += 4;
// Lower bounds is 1-based in SQL, 0-based in .NET.
dimLBounds[dimOffset] = PGUtil.ReadInt32(BackendData, dataOffset) - 1;
dataOffset += 4;
}
Array dst;
int[] dstOffsets;
dst = Array.CreateInstance(_elementConverter.FrameworkType, dimLengths, dimLBounds);
dstOffsets = new int[nDims];
// Right after the dimension descriptors begins array data.
// Populate the new array.
PopulateArrayFromBinaryArray(TypeInfo, BackendData, fieldValueSize, TypeModifier, ref dataOffset, dimLengths, dimLBounds, 0, dst, dstOffsets);
return(dst);
}
/// <summary>
/// Create a new ArrayBackendToNativeTypeConverter
/// </summary>
/// <param name="elementConverter"><see cref="NpgsqlBackendTypeInfo"/> for the element type.</param>
public ArrayBackendToNativeTypeConverter(NpgsqlBackendTypeInfo elementConverter)
{
_elementConverter = elementConverter;
}
/// <summary>
/// Convert a "char" to .NET char.
/// </summary>
internal static Object SingleCharBinaryToChar(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return((char)BackendData[0]);
}
/// <summary>
/// Convert a "char" to .NET char.
/// </summary>
internal static Object SingleCharTextToChar(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize, Int32 TypeModifier)
{
return(BackendData.Length > 0 ? (char)BackendData[0] : (char)0);
}
internal static object ToTimeStampTZ(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize,
Int32 typeModifier)
{
return(NpgsqlTimeStampTZ.Parse(backendData));
}
/// <summary>
/// interval
/// </summary>
internal static object ToInterval(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize,
Int32 typeModifier)
{
return(NpgsqlInterval.Parse(backendData));
}
/// <summary>
/// Convert a postgresql boolean to a System.Boolean.
/// </summary>
internal static Object BooleanTextToBoolean(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize,
Int32 TypeModifier)
{
return (BackendData[0] == (byte)ASCIIBytes.T || BackendData[0] == (byte)ASCIIBytes.t ? true : false);
}
internal static Object IntBinaryToInt(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize,
Int32 TypeModifier)
{
switch (BackendData.Length)
{
case 2: return IPAddress.NetworkToHostOrder(BitConverter.ToInt16(BackendData, 0));
case 4: return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(BackendData, 0));
case 8: return IPAddress.NetworkToHostOrder(BitConverter.ToInt64(BackendData, 0));
default: throw new NpgsqlException("Unexpected integer binary field length");
}
}
/// <summary>
/// Recursively populates an array from PB binary data representation.
/// </summary>
private void PopulateArrayFromBinaryArray(NpgsqlBackendTypeInfo TypeInfo, byte[] backendData, Int32 fieldValueSize, Int32 TypeModifier, ref int dataOffset, int[] dimLengths, int[] dimLBounds, int dimOffset, Array dst, int[] dstOffsets)
{
int dimensionLBound = dimLBounds[dimOffset];
int end = dimensionLBound + dimLengths[dimOffset];
if (dimOffset < dimLengths.Length - 1)
{
// Drill down recursively until we hit a single dimension array.
for (int i = dimensionLBound; i < end; i++)
{
dstOffsets[dimOffset] = i;
PopulateArrayFromBinaryArray(TypeInfo, backendData, fieldValueSize, TypeModifier, ref dataOffset, dimLengths, dimLBounds, dimOffset + 1, dst, dstOffsets);
}
}
else
{
// Populate a single dimension array.
for (int i = dimensionLBound; i < end; i++)
{
// Sanity check.
if (backendData.Length < dataOffset + 4)
{
throw new NpgsqlException("Out of backend data while reading binary array");
}
int elementLength;
// Each element consists of an int length identifier, followed by that many bytes of raw data.
// Length -1 indicates a NULL value, and is naturally followed by no data.
elementLength = PGUtil.ReadInt32(backendData, dataOffset);
dataOffset += 4;
if (elementLength == -1)
{
// This currently throws an exception on value types.
dst.SetValue(DBNull.Value, dstOffsets);
}
else
{
// Sanity check.
if (backendData.Length < dataOffset + elementLength)
{
throw new NpgsqlException("Out of backend data while reading binary array");
}
byte[] elementBinary;
// Get element data from backend data.
elementBinary = PGUtil.ReadBytes(backendData, dataOffset, elementLength);
object elementNative;
elementNative = _elementConverter.ConvertBackendBinaryToNative(elementBinary, fieldValueSize, TypeModifier);
dstOffsets[dimOffset] = i;
dst.SetValue(elementNative, dstOffsets);
dataOffset += elementLength;
}
}
}
}
/// <summary>
/// Convert a postgresql money to a System.Decimal.
/// </summary>
internal static Object ToMoney(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
// Will vary according to currency symbol, position of symbol and decimal and thousands separators, but will
// alwasy be two-decimal precision number using Arabic (0-9) digits, so we can extract just those digits and
// divide by 100.
return Convert.ToDecimal(EXCLUDE_DIGITS.Replace(BackendData, string.Empty), CultureInfo.InvariantCulture) / 100m;
}
/// <summary>
/// Byte array from bytea encoded as binary.
/// </summary>
internal static Object ByteaBinaryToByteArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return(BackendData);
}
internal static Object ToGuid(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return new Guid(BackendData);
}
/// <summary>
/// Convert a postgresql boolean to a System.Boolean.
/// </summary>
internal static Object BooleanTextToBoolean(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize,
Int32 TypeModifier)
{
return(BackendData[0] == (byte)ASCIIBytes.T || BackendData[0] == (byte)ASCIIBytes.t ? true : false);
}
internal bool TryGetTypeInfo(int fieldIndex, out NpgsqlBackendTypeInfo backendTypeInfo)
{
if (CurrentDescription == null)
{
throw new IndexOutOfRangeException(); //Essentially, all indices are out of range.
}
return (backendTypeInfo = CurrentDescription[fieldIndex].TypeInfo) != null;
}
/// <summary>
/// Convert a postgresql boolean to a System.Boolean.
/// </summary>
internal static Object BooleanBinaryToBoolean(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize,
Int32 TypeModifier)
{
return(BackendData[0] != 0);
}
/// <summary>
/// Creates an n-dimensional System.Array from PG binary representation.
/// This function reads the array header and sets up an n-dimensional System.Array object to hold its data.
/// PopulateArrayFromBinaryArray() is then called to carry out array population.
/// </summary>
public object ArrayBinaryToArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
// Sanity check.
if (BackendData.Length < 4)
{
throw new Exception("Insuffient backend data to describe dimension count in binary array header");
}
// Offset 0 holds an integer dscribing the number of dimensions in the array.
int nDims = PGUtil.ReadInt32(BackendData, 0);
// Sanity check.
if (nDims < 0)
{
throw new Exception("Invalid array dimension count encountered in binary array header");
}
// {PG handles 0-dimension arrays, but .net does not. Return a 0-size 1-dimensional array.
if (nDims == 0)
{
return Array.CreateInstance(_elementConverter.GetFrameworkType(TypeModifier), 0);
}
int dimOffset;
// Offset 12 begins an array of {int,int} objects, of length nDims.
int dataOffset = 12;
// Sanity check.
if (BackendData.Length < dataOffset + nDims * 8)
{
throw new Exception("Insuffient backend data to describe all expected dimensions in binary array header");
}
int[] dimLengths;
int[] dimLBounds;
dimLengths = new int[nDims];
dimLBounds = new int[nDims];
// Populate array dimension lengths and lower bounds.
for (dimOffset = 0 ; dimOffset < nDims ; dimOffset++)
{
dimLengths[dimOffset] = PGUtil.ReadInt32(BackendData, dataOffset);
dataOffset += 4;
// Lower bounds is 1-based in SQL, 0-based in .NET.
dimLBounds[dimOffset] = PGUtil.ReadInt32(BackendData, dataOffset) - 1;
dataOffset += 4;
}
Array dst;
int[] dstOffsets;
dst = Array.CreateInstance(_elementConverter.GetFrameworkType(TypeModifier), dimLengths, dimLBounds);
dstOffsets = new int[nDims];
// Right after the dimension descriptors begins array data.
// Populate the new array.
PopulateArrayFromBinaryArray(TypeInfo, BackendData, fieldValueSize, TypeModifier, ref dataOffset, dimLengths, dimLBounds, 0, dst, dstOffsets);
return dst;
}
internal static Object ToGuid(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return(new Guid(BackendData));
}
/// <summary>
/// Convert a "char" to .NET char.
/// </summary>
internal static Object SingleCharBinaryToChar(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return (char)BackendData[0];
}
internal static object ToDate(NpgsqlBackendTypeInfo typeInfo, byte[] bBackendData, Int16 typeSize, Int32 typeModifier)
{
string backendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return(NpgsqlDate.Parse(backendData));
}
/// <summary>
/// Convert UTF8 encoded text a string.
/// </summary>
internal static Object TextBinaryToString(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return(BackendEncoding.UTF8Encoding.GetString(BackendData));
}
/// <summary>
/// Byte array from bytea encoded as ASCII text, escaped or hex format.
/// </summary>
internal static Object ByteaTextToByteArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize, Int32 TypeModifier)
{
Int32 byteALength = BackendData.Length;
Int32 byteAPosition = 0;
if (byteALength >= 2 && BackendData[0] == (byte)ASCIIBytes.BackSlash && BackendData[1] == (byte)ASCIIBytes.x)
{
// PostgreSQL 8.5+'s bytea_output=hex format
byte[] result = new byte[(byteALength - 2) / 2];
#if UNSAFE
unsafe
{
fixed(byte *pBackendData = &BackendData[2])
{
fixed(byte *pResult = &result[0])
{
byte *pBackendData2 = pBackendData;
byte *pResult2 = pResult;
for (byteAPosition = 2; byteAPosition < byteALength; byteAPosition += 2)
{
*pResult2 = FastConverter.ToByteHexFormat(pBackendData2);
pBackendData2 += 2;
pResult2++;
}
}
}
}
#else
Int32 k = 0;
for (byteAPosition = 2; byteAPosition < byteALength; byteAPosition += 2)
{
result[k] = FastConverter.ToByteHexFormat(BackendData, byteAPosition);
k++;
}
#endif
return(result);
}
else
{
byte octalValue = 0;
MemoryStream ms = new MemoryStream();
while (byteAPosition < byteALength)
{
// The IsDigit is necessary in case we receive a \ as the octal value and not
// as the indicator of a following octal value in decimal format.
// i.e.: \201\301P\A
if (BackendData[byteAPosition] == (byte)ASCIIBytes.BackSlash)
{
if (byteAPosition + 1 == byteALength)
{
octalValue = (byte)ASCIIBytes.BackSlash;
byteAPosition++;
}
else if (BackendData[byteAPosition + 1] >= (byte)ASCIIBytes.b0 && BackendData[byteAPosition + 1] <= (byte)ASCIIBytes.b7)
{
octalValue = FastConverter.ToByteEscapeFormat(BackendData, byteAPosition + 1);
byteAPosition += 4;
}
else
{
octalValue = (byte)ASCIIBytes.BackSlash;
byteAPosition += 2;
}
}
else
{
octalValue = BackendData[byteAPosition];
byteAPosition++;
}
ms.WriteByte((Byte)octalValue);
}
return(ms.ToArray());
}
}
/// <summary>
/// Byte array from bytea encoded as binary.
/// </summary>
internal static Object ByteaBinaryToByteArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
return BackendData;
}
/// <summary>
/// Convert a postgresql money to a System.Decimal.
/// </summary>
internal static Object ToMoney(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
{
// It's a number with a $ on the beginning...
return(Convert.ToDecimal(BackendData.Substring(1, BackendData.Length - 1), CultureInfo.InvariantCulture));
}
/// <summary>
/// Convert a postgresql boolean to a System.Boolean.
/// </summary>
internal static Object BooleanBinaryToBoolean(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize,
Int32 TypeModifier)
{
return (BackendData[0] != 0);
}
/// <summary>
/// Inet.
/// </summary>
internal static Object ToInet(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
{
return(new NpgsqlInet(BackendData));
}
/// <summary>
/// Convert a postgresql bit to a System.Boolean.
/// </summary>
internal static Object ToBit(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
// Current tests seem to expect single-bit bitstrings to behave as boolean (why?)
//
// To ensure compatibility we return a bool if the bitstring is single-length.
// Maybe we don't need to do this (why do we?) or maybe people used to some other,
// but taking a conservative approach here.
//
// It means that IDataReader.GetValue() can't be used safely for bitstrings that
// may be single-bit, but NpgsqlDataReader.GetBitString() can deal with the conversion
// below by reversing it, so if GetBitString() is used, no harm is done.
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
BitString bs = BitString.Parse(BackendData);
return bs.Length == 1 ? (object)bs[0] : bs;
}
/// <summary>
/// Find a NpgsqlNativeTypeInfo in the default types map that can handle objects
/// of the given NpgsqlDbType.
/// </summary>
public static bool TryGetBackendTypeInfo(String BackendTypeName, out NpgsqlBackendTypeInfo TypeInfo)
{
return(DefaultBackendInfoMapping.TryGetValue(BackendTypeName, out TypeInfo));
}
/// <summary>
/// Convert a postgresql time to a System.DateTime.
/// </summary>
internal static Object ToTime(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return
DateTime.ParseExact(BackendData, TimeFormats, DateTimeFormatInfo.InvariantInfo,
DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AllowWhiteSpaces);
}
/// <summary>
/// Convert a postgresql boolean to a System.Boolean.
/// </summary>
internal static Object ToBoolean(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize,
Int32 TypeModifier)
{
return(BackendData.ToLower() == "t" ? true : false);
}
/// <summary>
/// Convert a postgresql float4 or float8 to a System.Float or System.Double respectively.
/// </summary>
internal static Object Float4Float8BinaryToFloatDouble(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize, Int32 TypeModifier)
{
switch (BackendData.Length)
{
case 4: return BitConverter.ToSingle(PGUtil.HostNetworkByteOrderSwap(BackendData), 0);
case 8: return BitConverter.ToDouble(PGUtil.HostNetworkByteOrderSwap(BackendData), 0);
default: throw new NpgsqlException("Unexpected float binary field length");
}
}
/// <summary>
/// Convert a postgresql time to a System.DateTime.
/// </summary>
internal static Object ToTime(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
{
return
(DateTime.ParseExact(BackendData, TimeFormats, DateTimeFormatInfo.InvariantInfo,
DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AllowWhiteSpaces));
}
/// <summary>
/// Circle.
/// </summary>
internal static Object ToCircle(NpgsqlBackendTypeInfo TypeInfo, byte[] bBackendData, Int16 TypeSize, Int32 TypeModifier)
{
string BackendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
Match m = circleRegex.Match(BackendData);
return
new NpgsqlCircle(
new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)),
Single.Parse(m.Groups[3].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat));
}
///<summary>
/// This method is responsible to convert the string received from the backend
/// to the corresponding NpgsqlType.
/// The given TypeInfo is called upon to do the conversion.
/// If no TypeInfo object is provided, no conversion is performed.
/// </summary>
public static Object ConvertBackendStringToSystemType(NpgsqlBackendTypeInfo TypeInfo, String data, Int16 typeSize, Int32 typeModifier)
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "ConvertBackendStringToSystemType");
if (TypeInfo != null) {
return TypeInfo.ConvertToNative(data, typeSize, typeModifier);
} else {
return data;
}
}
internal static object ToTimeStampTZ(NpgsqlBackendTypeInfo typeInfo, byte[] bBackendData, Int16 typeSize,
Int32 typeModifier)
{
string backendData = BackendEncoding.UTF8Encoding.GetString(bBackendData);
return NpgsqlTimeStampTZ.Parse(backendData);
}
///<summary>
/// This method creates (or retrieves from cache) a mapping between type and OID
/// of all natively supported postgresql data types.
/// This is needed as from one version to another, this mapping can be changed and
/// so we avoid hardcoding them.
/// </summary>
/// <returns>NpgsqlTypeMapping containing all known data types. The mapping must be
/// cloned before it is modified because it is cached; changes made by one connection may
/// effect another connection.</returns>
public static NpgsqlBackendTypeMapping CreateAndLoadInitialTypesMapping(NpgsqlConnector conn)
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "LoadTypesMapping");
// [TODO] Verify another way to get higher concurrency.
lock(CLASSNAME)
{
// Check the cache for an initial types map.
NpgsqlBackendTypeMapping oidToNameMapping = (NpgsqlBackendTypeMapping) BackendTypeMappingCache[conn.ServerVersion];
if (oidToNameMapping != null)
{
return oidToNameMapping;
}
// Not in cache, create a new one.
oidToNameMapping = new NpgsqlBackendTypeMapping();
// Create a list of all natively supported postgresql data types.
NpgsqlBackendTypeInfo[] TypeInfoList = new NpgsqlBackendTypeInfo[]
{
new NpgsqlBackendTypeInfo(0, "unknown", NpgsqlDbType.Text, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "refcursor", NpgsqlDbType.Refcursor, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "char", NpgsqlDbType.Char, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "bpchar", NpgsqlDbType.Text, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "varchar", NpgsqlDbType.Varchar, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "text", NpgsqlDbType.Text, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "name", NpgsqlDbType.Text, DbType.String, typeof(String),
null),
new NpgsqlBackendTypeInfo(0, "bytea", NpgsqlDbType.Bytea, DbType.Binary, typeof(Byte[]),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToBinary)),
new NpgsqlBackendTypeInfo(0, "bit", NpgsqlDbType.Bit, DbType.Boolean, typeof(Boolean),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToBit)),
new NpgsqlBackendTypeInfo(0, "bool", NpgsqlDbType.Boolean, DbType.Boolean, typeof(Boolean),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToBoolean)),
new NpgsqlBackendTypeInfo(0, "int2", NpgsqlDbType.Smallint, DbType.Int16, typeof(Int16),
null),
new NpgsqlBackendTypeInfo(0, "int4", NpgsqlDbType.Integer, DbType.Int32, typeof(Int32),
null),
new NpgsqlBackendTypeInfo(0, "int8", NpgsqlDbType.Bigint, DbType.Int64, typeof(Int64),
null),
new NpgsqlBackendTypeInfo(0, "oid", NpgsqlDbType.Bigint, DbType.Int64, typeof(Int64),
null),
new NpgsqlBackendTypeInfo(0, "float4", NpgsqlDbType.Real, DbType.Single, typeof(Single),
null),
new NpgsqlBackendTypeInfo(0, "float8", NpgsqlDbType.Double, DbType.Double, typeof(Double),
null),
new NpgsqlBackendTypeInfo(0, "numeric", NpgsqlDbType.Numeric, DbType.Decimal, typeof(Decimal),
null),
new NpgsqlBackendTypeInfo(0, "inet", NpgsqlDbType.Inet, DbType.Object, typeof(NpgsqlInet), new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToInet)),
new NpgsqlBackendTypeInfo(0, "money", NpgsqlDbType.Money, DbType.Decimal, typeof(Decimal),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToMoney)),
new NpgsqlBackendTypeInfo(0, "date", NpgsqlDbType.Date, DbType.Date, typeof(DateTime),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToDate)),
new NpgsqlBackendTypeInfo(0, "time", NpgsqlDbType.Time, DbType.Time, typeof(DateTime),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToTime)),
new NpgsqlBackendTypeInfo(0, "timetz", NpgsqlDbType.Time, DbType.Time, typeof(DateTime),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToTime)),
new NpgsqlBackendTypeInfo(0, "timestamp", NpgsqlDbType.Timestamp, DbType.DateTime, typeof(DateTime),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToDateTime)),
new NpgsqlBackendTypeInfo(0, "timestamptz", NpgsqlDbType.Timestamp, DbType.DateTime, typeof(DateTime),
new ConvertBackendToNativeHandler(BasicBackendToNativeTypeConverter.ToDateTime)),
new NpgsqlBackendTypeInfo(0, "point", NpgsqlDbType.Point, DbType.Object, typeof(NpgsqlPoint),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToPoint)),
new NpgsqlBackendTypeInfo(0, "lseg", NpgsqlDbType.LSeg, DbType.Object, typeof(NpgsqlLSeg),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToLSeg)),
new NpgsqlBackendTypeInfo(0, "path", NpgsqlDbType.Path, DbType.Object, typeof(NpgsqlPath),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToPath)),
new NpgsqlBackendTypeInfo(0, "box", NpgsqlDbType.Box, DbType.Object, typeof(NpgsqlBox),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToBox)),
new NpgsqlBackendTypeInfo(0, "circle", NpgsqlDbType.Circle, DbType.Object, typeof(NpgsqlCircle),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToCircle)),
new NpgsqlBackendTypeInfo(0, "polygon", NpgsqlDbType.Polygon, DbType.Object, typeof(NpgsqlPolygon),
new ConvertBackendToNativeHandler(ExtendedBackendToNativeTypeConverter.ToPolygon)),
};
// Attempt to map each type info in the list to an OID on the backend and
// add each mapped type to the new type mapping object.
LoadTypesMappings(conn, oidToNameMapping, TypeInfoList);
// Add this mapping to the per-server-version cache so we don't have to
// do these expensive queries on every connection startup.
BackendTypeMappingCache.Add(conn.ServerVersion, oidToNameMapping);
return oidToNameMapping;
}
}
/// <summary>
/// Byte array from bytea encoded as ASCII text, escaped or hex format.
/// </summary>
internal static Object ByteaTextToByteArray(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize, Int32 TypeModifier)
{
Int32 byteALength = BackendData.Length;
Int32 byteAPosition = 0;
if (byteALength >= 2 && BackendData[0] == (byte)ASCIIBytes.BackSlash && BackendData[1] == (byte)ASCIIBytes.x)
{
// PostgreSQL 8.5+'s bytea_output=hex format
byte[] result = new byte[(byteALength - 2) / 2];
#if UNSAFE
unsafe
{
fixed (byte* pBackendData = &BackendData[2])
{
fixed (byte* pResult = &result[0])
{
byte* pBackendData2 = pBackendData;
byte* pResult2 = pResult;
for (byteAPosition = 2 ; byteAPosition < byteALength ; byteAPosition += 2)
{
*pResult2 = FastConverter.ToByteHexFormat(pBackendData2);
pBackendData2 += 2;
pResult2++;
}
}
}
}
#else
Int32 k = 0;
for (byteAPosition = 2 ; byteAPosition < byteALength ; byteAPosition += 2)
{
result[k] = FastConverter.ToByteHexFormat(BackendData, byteAPosition);
k++;
}
#endif
return result;
}
else
{
byte octalValue = 0;
MemoryStream ms = new MemoryStream();
while (byteAPosition < byteALength)
{
// The IsDigit is necessary in case we receive a \ as the octal value and not
// as the indicator of a following octal value in decimal format.
// i.e.: \201\301P\A
if (BackendData[byteAPosition] == (byte)ASCIIBytes.BackSlash)
{
if (byteAPosition + 1 == byteALength)
{
octalValue = (byte)ASCIIBytes.BackSlash;
byteAPosition++;
}
else if (BackendData[byteAPosition + 1] >= (byte)ASCIIBytes.b0 && BackendData[byteAPosition + 1] <= (byte)ASCIIBytes.b7)
{
octalValue = FastConverter.ToByteEscapeFormat(BackendData, byteAPosition + 1);
byteAPosition += 4;
}
else
{
octalValue = (byte)ASCIIBytes.BackSlash;
byteAPosition += 2;
}
}
else
{
octalValue = BackendData[byteAPosition];
byteAPosition++;
}
ms.WriteByte((Byte)octalValue);
}
return ms.ToArray();
}
}
// CHECKME
// Not sure what to do with this one. I don't believe we ever ask for a binary
// formatting, so this shouldn't even be used right now.
// At some point this will need to be merged into the type converter system somehow?
public static Object ConvertBackendBytesToSystemType(NpgsqlBackendTypeInfo TypeInfo, Byte[] data, Encoding encoding, Int32 fieldValueSize, Int32 typeModifier)
{
NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "ConvertBackendBytesToStytemType");
// We are never guaranteed to know about every possible data type the server can send us.
// When we encounter an unknown type, we punt and return the data without modification.
if (TypeInfo == null)
return data;
switch (TypeInfo.NpgsqlDbType)
{
case NpgsqlDbType.Bytea:
return data;
/*case NpgsqlDbType.Boolean:
return BitConverter.ToBoolean(data, 0);
case NpgsqlDbType.DateTime:
return DateTime.MinValue.AddTicks(IPAddress.NetworkToHostOrder(BitConverter.ToInt64(data, 0)));
case NpgsqlDbType.Int16:
return IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));
case NpgsqlDbType.Int32:
return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, 0));
case NpgsqlDbType.Int64:
return IPAddress.NetworkToHostOrder(BitConverter.ToInt64(data, 0));
case NpgsqlDbType.String:
case NpgsqlDbType.AnsiString:
case NpgsqlDbType.StringFixedLength:
return encoding.GetString(data, 0, fieldValueSize);*/
default:
throw new InvalidCastException("Type not supported in binary format");
}
return null;
}
/// <summary>
/// Create a new ArrayBackendToNativeTypeConverter
/// </summary>
/// <param name="elementConverter"><see cref="NpgsqlBackendTypeInfo"/> for the element type.</param>
public ArrayBackendToNativeTypeConverter(NpgsqlBackendTypeInfo elementConverter)
{
_elementConverter = elementConverter;
}
/// <summary>
/// Convert a postgresql bit to a System.Boolean if length is 1, else a BitString.
/// </summary>
internal static Object ToBitBinary(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int32 fieldValueSize,
Int32 TypeModifier)
{
BitString bs = new BitString(BackendData);
return TypeInfo.NpgsqlDbType == NpgsqlDbType.Bit && TypeModifier == 1 ? (object)bs[0] : bs;
}
/// <summary>
/// Creates an array list from pg represenation of an array.
/// Multidimensional arrays are treated as ArrayLists of ArrayLists
/// </summary>
private ArrayList ToArrayList(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 elementTypeSize,
Int32 elementTypeModifier)
{
ArrayList list = new ArrayList();
//remove the braces on either side and work on what they contain.
string stripBraces = BackendData.Trim().Substring(1, BackendData.Length - 2).Trim();
if (stripBraces.Length == 0)
{
return list;
}
if (stripBraces[0] == '{')
//there are still braces so we have an n-dimension array. Recursively build an ArrayList of ArrayLists
{
foreach (string arrayChunk in ArrayChunkEnumeration(stripBraces))
{
list.Add(ToArrayList(TypeInfo, arrayChunk, elementTypeSize, elementTypeModifier));
}
}
else
//We're either dealing with a 1-dimension array or treating a row of an n-dimension array. In either case parse the elements and put them in our ArrayList
{
foreach (string token in TokenEnumeration(stripBraces))
{
//Use the NpgsqlBackendTypeInfo for the element type to obtain each element.
list.Add(_elementConverter.ConvertBackendTextToNative(BackendEncoding.UTF8Encoding.GetBytes(token), elementTypeSize, elementTypeModifier));
}
}
return list;
}
/// <summary>
/// Convert a "char" to .NET char.
/// </summary>
internal static Object SingleCharTextToChar(NpgsqlBackendTypeInfo TypeInfo, byte[] BackendData, Int16 TypeSize, Int32 TypeModifier)
{
return BackendData.Length > 0 ? (char)BackendData[0] : (char)0;
}
/// <summary>
/// Recursively populates an array from PB binary data representation.
/// </summary>
private void PopulateArrayFromBinaryArray(NpgsqlBackendTypeInfo TypeInfo, byte[] backendData, Int32 fieldValueSize, Int32 TypeModifier, ref int dataOffset, int[] dimLengths, int[] dimLBounds, int dimOffset, Array dst, int[] dstOffsets)
{
int dimensionLBound = dimLBounds[dimOffset];
int end = dimensionLBound + dimLengths[dimOffset];
if (dimOffset < dimLengths.Length - 1)
{
// Drill down recursively until we hit a single dimension array.
for (int i = dimensionLBound ; i < end ; i++)
{
dstOffsets[dimOffset] = i;
PopulateArrayFromBinaryArray(TypeInfo, backendData, fieldValueSize, TypeModifier, ref dataOffset, dimLengths, dimLBounds, dimOffset + 1, dst, dstOffsets);
}
}
else
{
// Populate a single dimension array.
for (int i = dimensionLBound ; i < end ; i++)
{
// Sanity check.
if (backendData.Length < dataOffset + 4)
{
throw new Exception("Out of backend data while reading binary array");
}
int elementLength;
// Each element consists of an int length identifier, followed by that many bytes of raw data.
// Length -1 indicates a NULL value, and is naturally followed by no data.
elementLength = PGUtil.ReadInt32(backendData, dataOffset);
dataOffset += 4;
if (elementLength == -1)
{
// This currently throws an exception on value types.
dst.SetValue(DBNull.Value, dstOffsets);
}
else
{
// Sanity check.
if (backendData.Length < dataOffset + elementLength)
{
throw new Exception("Out of backend data while reading binary array");
}
byte[] elementBinary;
// Get element data from backend data.
elementBinary = PGUtil.ReadBytes(backendData, dataOffset, elementLength);
object elementNative;
elementNative = _elementConverter.ConvertBackendBinaryToNative(elementBinary, fieldValueSize, TypeModifier);
dstOffsets[dimOffset] = i;
dst.SetValue(elementNative, dstOffsets);
dataOffset += elementLength;
}
}
}
}
public bool TryGetValue(int oid, out NpgsqlBackendTypeInfo value)
{
return(OIDIndex.TryGetValue(oid, out value));
}
