{

readonly RowDescriptionMessage _rowDescription;

readonly NpgsqlConnection _connection;

internal DbColumnSchemaGenerator(NpgsqlConnection connection, RowDescriptionMessage rowDescription)

{

_connection = connection;

_rowDescription = rowDescription;

}

const string GetColumnsQuery = @"

internal ReadOnlyCollection<NpgsqlDbColumn> GetColumnSchema()

{

var fields = _rowDescription.Fields;

if (fields.Count == 0)

return new List<NpgsqlDbColumn>().AsReadOnly();

var result = new List<NpgsqlDbColumn>(fields.Count);

for (var i = 0; i < fields.Count; i++)

result.Add(null);

var populatedColumns = 0;

// We have two types of fields - those which correspond to actual database columns

// and those that don't (e.g. SELECT 8). For the former we load lots of info from

// the backend, for the latter we only have the RowDescription

var columnFieldFilter = _rowDescription.Fields

.Where(f => f.TableOID != 0) // Only column fields

.Select(c => $"(attr.attrelid={c.TableOID} AND attr.attnum={c.ColumnAttributeNumber})")

.Join(" OR ");

if (columnFieldFilter != "")

{

var query = string.Format(GetColumnsQuery, columnFieldFilter);

#if NET45 || NET451

using (var connection = (NpgsqlConnection)((ICloneable)_connection).Clone())

#else

using (var connection = _connection.Clone())

#endif

{

connection.Open();

using (var cmd = new NpgsqlCommand(query, connection))

using (var reader = cmd.ExecuteReader())

{

for (; reader.Read(); populatedColumns++)

{

var column = LoadColumnDefinition(reader);

var ordinal = fields.FindIndex(f => f.TableOID == column.TableOID && f.ColumnAttributeNumber - 1 == column.ColumnAttributeNumber);

Contract.Assert(ordinal >= 0);

var field = fields[ordinal];

Contract.Assert(field.Name == column.ColumnName);

// The column's ordinal is with respect to the resultset, not its table

column.ColumnOrdinal = ordinal;

// Overwrite the column's DataType because the field provides more information about it

column.DataType = field.FieldType;

result[ordinal] = column;

}

}

if (populatedColumns == fields.Count)

{

// All columns were regular table columns that got loaded, we're done

Contract.Assert(result.All(c => c != null));

return result.AsReadOnly();

}

}

}

// We had some fields which don't correspond to regular table columns

// Fill in whatever info we have from the RowDescription itself

for (var i = 0; i < fields.Count; i++)

{

if (result[i] != null)

continue;

var column = SetUpNonColumnField(fields[i]);

column.ColumnOrdinal = i;

result[i] = column;

populatedColumns++;

}

if (populatedColumns != fields.Count)

throw new NpgsqlException("Could not load all columns for the resultset");

return result.AsReadOnly();

}

NpgsqlDbColumn LoadColumnDefinition(NpgsqlDataReader reader)

{

var columnName = reader.GetString(reader.GetOrdinal("attname"));

var column = new NpgsqlDbColumn

{

AllowDBNull = !reader.GetBoolean(reader.GetOrdinal("attnotnull")),

BaseCatalogName = _connection.Database,

BaseColumnName = columnName,

BaseSchemaName = reader.GetString(reader.GetOrdinal("nspname")),

BaseServerName = _connection.Host,

BaseTableName = reader.GetString(reader.GetOrdinal("relname")),

ColumnName = columnName,

ColumnOrdinal = reader.GetInt32(reader.GetOrdinal("attnum")) - 1,

ColumnAttributeNumber = (short)(reader.GetInt16(reader.GetOrdinal("attnum")) - 1),

IsKey = reader.GetBoolean(reader.GetOrdinal("isprimarykey")),

IsReadOnly = !reader.GetBoolean(reader.GetOrdinal("is_updatable")),

IsUnique = reader.GetBoolean(reader.GetOrdinal("isunique")),

DataTypeName = reader.GetString(reader.GetOrdinal("typname")),

TableOID = reader.GetFieldValue<uint>(reader.GetOrdinal("attrelid")),

TypeOID = reader.GetFieldValue<uint>(reader.GetOrdinal("typoid"))

};

var defaultValueOrdinal = reader.GetOrdinal("default");

column.DefaultValue = reader.IsDBNull(defaultValueOrdinal) ? null : reader.GetString(defaultValueOrdinal);

column.IsAutoIncrement = column.DefaultValue != null && column.DefaultValue.StartsWith("nextval(");

ColumnPostConfig(column, reader.GetInt32(reader.GetOrdinal("atttypmod")));

return column;

}

NpgsqlDbColumn SetUpNonColumnField(FieldDescription field)

{

var columnName = field.Name.StartsWith("?column?") ? null : field.Name;

var column = new NpgsqlDbColumn

{

ColumnName = columnName,

BaseCatalogName = _connection.Database,

BaseColumnName = columnName,

BaseServerName = _connection.Host,

IsReadOnly = true,

DataTypeName = field.DataTypeName,

TypeOID = field.TypeOID,

TableOID = field.TableOID,

ColumnAttributeNumber = field.ColumnAttributeNumber

};

ColumnPostConfig(column, field.TypeModifier);

return column;

}

/// <summary>

/// Performs some post-setup configuration that's common to both table columns and non-columns.

/// </summary>

void ColumnPostConfig(NpgsqlDbColumn column, int typeModifier)

{

TypeHandler handler;

column.DataType = _connection.Connector.TypeHandlerRegistry.TryGetByOID(column.TypeOID, out handler)

? handler.GetFieldType()

: null;

if (column.DataType != null)

{

column.IsLong = handler is ByteaHandler;

if (handler is ICompositeHandler)

column.UdtAssemblyQualifiedName = column.DataType.AssemblyQualifiedName;

}

if (typeModifier == -1)

return;

switch (column.DataTypeName)

{

case "bpchar":

case "char":

case "varchar":

column.ColumnSize = typeModifier - 4;

break;

case "numeric":

case "decimal":

// See http://stackoverflow.com/questions/3350148/where-are-numeric-precision-and-scale-for-a-field-found-in-the-pg-catalog-tables

column.NumericPrecision = ((typeModifier - 4) >> 16) & 65535;

column.NumericScale = (typeModifier - 4) & 65535;

break;

}

}