Ejemplo n.º 1
0
        internal bool TryGetByOID(uint oid, out TypeHandler handler)
        {
            if (ByOID.TryGetValue(oid, out handler))
            {
                return(true);
            }
            if (!_postgresTypes.ByOID.TryGetValue(oid, out var postgresType))
            {
                return(false);
            }

            handler = postgresType.Activate(this);
            return(true);
        }
Ejemplo n.º 2
0
        void LoadCompositeFields(DbDataReader reader)
        {
            PostgresCompositeType currentComposite = null;

            while (reader.Read())
            {
                var ns       = reader.GetString(reader.GetOrdinal("nspname"));
                var name     = reader.GetString(reader.GetOrdinal("typname"));
                var fullName = $"{ns}.{name}";
                if (fullName != currentComposite?.FullName)
                {
                    currentComposite = ByFullName[fullName] as PostgresCompositeType;
                    if (currentComposite == null)
                    {
                        Log.Error($"Ignoring non-composite type {fullName} when trying to load composite fields");
                        continue;
                    }
                }
                currentComposite.Fields.Add(new PostgresCompositeType.Field
                {
                    PgName  = reader.GetString(reader.GetOrdinal("attname")),
                    TypeOID = Convert.ToUInt32(reader[reader.GetOrdinal("atttypid")])
                });
            }

            // Our pass above loaded composite fields with their type OID only, do a second
            // pass to resolve them to PostgresType references (since types can come in any order)
            foreach (var compositeType in CompositeTypes.ToArray())
            {
                foreach (var field in compositeType.Fields)
                {
                    if (!ByOID.TryGetValue(field.TypeOID, out field.Type))
                    {
                        Log.Error($"Skipping composite type {compositeType.DisplayName} with field {field.PgName} with type OID {field.TypeOID}, which could not be resolved to a PostgreSQL type.");
                        Remove(compositeType);
                        CompositeTypes.Remove(compositeType);
                        goto outer;
                    }
                }
                // ReSharper disable once RedundantJumpStatement
                outer : continue;
            }
        }
Ejemplo n.º 3
0
 void Remove(PostgresType pgType)
 {
     ByOID.Remove(pgType.OID);
     ByName.Remove(pgType.Name);
     ByFullName.Remove(pgType.FullName);
 }
Ejemplo n.º 4
0
        void LoadBackendType(DbDataReader reader, NpgsqlConnector connector)
        {
            var ns   = reader.GetString(reader.GetOrdinal("nspname"));
            var name = reader.GetString(reader.GetOrdinal("typname"));
            var oid  = Convert.ToUInt32(reader[reader.GetOrdinal("oid")]);

            Debug.Assert(name != null);
            Debug.Assert(oid != 0);

            var typeChar = reader.GetString(reader.GetOrdinal("type"))[0];

            switch (typeChar)
            {
            case 'b':  // Normal base type
                var baseType = new PostgresBaseType(ns, name, oid);
                Add(baseType);
                BaseTypes.Add(baseType);
                return;

            case 'a': // Array
            {
                var elementOID = Convert.ToUInt32(reader[reader.GetOrdinal("elemoid")]);
                Debug.Assert(elementOID > 0);
                if (!ByOID.TryGetValue(elementOID, out var elementPostgresType))
                {
                    Log.Trace($"Array type '{name}' refers to unknown element with OID {elementOID}, skipping", connector.Id);
                    return;
                }

                var arrayType = new PostgresArrayType(ns, name, oid, elementPostgresType);
                Add(arrayType);
                ArrayTypes.Add(arrayType);
                return;
            }

            case 'r': // Range
            {
                var elementOID = Convert.ToUInt32(reader[reader.GetOrdinal("elemoid")]);
                Debug.Assert(elementOID > 0);
                if (!ByOID.TryGetValue(elementOID, out var subtypePostgresType))
                {
                    Log.Trace($"Range type '{name}' refers to unknown subtype with OID {elementOID}, skipping", connector.Id);
                    return;
                }

                var rangeType = new PostgresRangeType(ns, name, oid, subtypePostgresType);
                Add(rangeType);
                RangeTypes.Add(rangeType);
                return;
            }

            case 'e':   // Enum
                var enumType = new PostgresEnumType(ns, name, oid);
                Add(enumType);
                EnumTypes.Add(enumType);
                return;

            case 'c':   // Composite
                var compositeType = new PostgresCompositeType(ns, name, oid);
                Add(compositeType);
                CompositeTypes.Add(compositeType);
                return;

            case 'd':   // Domain
                var baseTypeOID = Convert.ToUInt32(reader[reader.GetOrdinal("typbasetype")]);
                Debug.Assert(baseTypeOID > 0);
                if (!ByOID.TryGetValue(baseTypeOID, out var basePostgresType))
                {
                    Log.Trace($"Domain type '{name}' refers to unknown base type with OID {baseTypeOID}, skipping", connector.Id);
                    return;
                }
                var domainType = new PostgresDomainType(ns, name, oid, basePostgresType);
                Add(domainType);
                DomainTypes.Add(domainType);
                return;

            case 'p':   // pseudo-type (record, void)
                // Hack this as a base type
                goto case 'b';

            default:
                throw new ArgumentOutOfRangeException($"Unknown typtype for type '{name}' in pg_type: {typeChar}");
            }
        }