decode_properties()

static void decode_properties ( struct flatgeobuf_decode_ctx *  ctx, Datum *  values, bool *  isnull  )

static

Definition at line 279 of file flatgeobuf.c.

{
        uint16_t i, ci;
        flatgeobuf_column *column;
        uint8_t type;
        uint32_t offset = 0;
        uint8_t *data = ctx->ctx->properties;
        uint32_t size = ctx->ctx->properties_len;
 
        POSTGIS_DEBUGF(3, "flatgeobuf: decode_properties from byte array with length %d at offset %d", size, offset);
 
        // TODO: init isnull
 
        if (size > 0 && size < (sizeof(uint16_t) + sizeof(uint8_t)))
                elog(ERROR, "flatgeobuf: decode_properties: Unexpected properties data size %d", size);
        while (offset + 1 < size) {
                if (offset + sizeof(uint16_t) > size)
                        elog(ERROR, "flatgeobuf: decode_properties: Unexpected offset %d", offset);
                memcpy(&i, data + offset, sizeof(uint16_t));
                ci = i + 2;
                offset += sizeof(uint16_t);
                if (i >= ctx->ctx->columns_size)
                        elog(ERROR, "flatgeobuf: decode_properties: Column index %hu out of range", i);
                column = ctx->ctx->columns[i];
                type = column->type;
                isnull[ci] = false;
                switch (type) {
                case flatgeobuf_column_type_bool: {
                        uint8_t value;
                        if (offset + sizeof(uint8_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for bool value");
                        memcpy(&value, data + offset, sizeof(uint8_t));
                        values[ci] = BoolGetDatum(value);
                        offset += sizeof(uint8_t);
                        break;
                }
                case flatgeobuf_column_type_byte: {
                        int8_t value;
                        if (offset + sizeof(int8_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for byte value");
                        memcpy(&value, data + offset, sizeof(int8_t));
                        values[ci] = Int8GetDatum(value);
                        offset += sizeof(int8_t);
                        break;
                }
                case flatgeobuf_column_type_ubyte: {
                        uint8_t value;
                        if (offset + sizeof(uint8_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for ubyte value");
                        memcpy(&value, data + offset, sizeof(uint8_t));
                        values[ci] = UInt8GetDatum(value);
                        offset += sizeof(uint8_t);
                        break;
                }
                case flatgeobuf_column_type_short: {
                        int16_t value;
                        if (offset + sizeof(int16_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for short value");
                        memcpy(&value, data + offset, sizeof(int16_t));
                        values[ci] = Int16GetDatum(value);
                        offset += sizeof(int16_t);
                        break;
                }
                case flatgeobuf_column_type_ushort: {
                        uint16_t value;
                        if (offset + sizeof(uint16_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for ushort value");
                        memcpy(&value, data + offset, sizeof(uint16_t));
                        values[ci] = UInt16GetDatum(value);
                        offset += sizeof(uint16_t);
                        break;
                }
                case flatgeobuf_column_type_int: {
                        int32_t value;
                        if (offset + sizeof(int32_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for int value");
                        memcpy(&value, data + offset, sizeof(int32_t));
                        values[ci] = Int32GetDatum(value);
                        offset += sizeof(int32_t);
                        break;
                }
                case flatgeobuf_column_type_uint: {
                        uint32_t value;
                        if (offset + sizeof(uint32_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for uint value");
                        memcpy(&value, data + offset, sizeof(uint32_t));
                        values[ci] = UInt32GetDatum(value);
                        offset += sizeof(uint32_t);
                        break;
                }
                case flatgeobuf_column_type_long: {
                        int64_t value;
                        if (offset + sizeof(int64_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for long value");
                        memcpy(&value, data + offset, sizeof(int64_t));
                        values[ci] = Int64GetDatum(value);
                        offset += sizeof(int64_t);
                        break;
                }
                case flatgeobuf_column_type_ulong: {
                        uint64_t value;
                        if (offset + sizeof(uint64_t) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for ulong value");
                        memcpy(&value, data + offset, sizeof(uint64_t));
                        values[ci] = UInt64GetDatum(value);
                        offset += sizeof(uint64_t);
                        break;
                }
                case flatgeobuf_column_type_float: {
                        float value;
                        if (offset + sizeof(float) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for float value");
                        memcpy(&value, data + offset, sizeof(float));
                        values[ci] = Float4GetDatum(value);
                        offset += sizeof(float);
                        break;
                }
                case flatgeobuf_column_type_double: {
                        double value;
                        if (offset + sizeof(double) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for double value");
                        memcpy(&value, data + offset, sizeof(double));
                        values[ci] = Float8GetDatum(value);
                        offset += sizeof(double);
                        break;
                }
                case flatgeobuf_column_type_string: {
                        uint32_t len;
                        if (offset + sizeof(len) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for string value");
                        memcpy(&len, data + offset, sizeof(uint32_t));
                        offset += sizeof(len);
                        values[ci] = PointerGetDatum(cstring_to_text_with_len((const char *) data + offset, len));
                        offset += len;
                        break;
                }
                case flatgeobuf_column_type_datetime: {
                        uint32_t len;
                        char *buf;
                        char workbuf[MAXDATELEN + MAXDATEFIELDS];
                        char *field[MAXDATEFIELDS];
                        int ftype[MAXDATEFIELDS];
                        int dtype;
                        int nf;
                        struct pg_tm tt, *tm = &tt;
                        fsec_t fsec;
                        int tzp;
                        TimestampTz dttz;
#if POSTGIS_PGSQL_VERSION >= 160
                        DateTimeErrorExtra extra;
#endif
                        if (offset + sizeof(len) > size)
                                elog(ERROR, "flatgeobuf: decode_properties: Invalid size for string value");
                        memcpy(&len, data + offset, sizeof(uint32_t));
                        offset += sizeof(len);
                        buf = palloc0(len + 1);
                        memcpy(buf, (const char *) data + offset, len);
                        ParseDateTime((const char *) buf, workbuf, sizeof(workbuf), field, ftype, MAXDATEFIELDS, &nf);
 
#if POSTGIS_PGSQL_VERSION >= 160
                        DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp, &extra);
#else
                        DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, &tzp);
#endif
                        tm2timestamp(tm, fsec, &tzp, &dttz);
                        values[ci] = TimestampTzGetDatum(dttz);
                        offset += len;
                        break;
                }
                // TODO: find out how to handle string to jsonb Datum
                // case FlatGeobuf_ColumnType_Json:
                //      if (offset + sizeof(len) > size)
                //              elog(ERROR, "flatgeobuf: decode_properties: Invalid size for json value");
                //      len = *((uint32_t *)(data + offset));
                //      offset += sizeof(len);
                //      values[ci] = jsonb_from_cstring((const char *) data + offset, len);
                //      offset += len;
                //      break;
                default:
                        elog(ERROR, "flatgeobuf: decode_properties: Unknown type %d", type);
                }
        }
 
}

References flatgeobuf_decode_ctx::ctx.

Referenced by flatgeobuf_decode_row().

Here is the caller graph for this function: