Function dict_encoded_roundtrip

nodedb-columnar/src/reader/block_decode.rs:606–665

()

    /// and verify the dictionary and IDs match the original values.
    #[test]
    fn dict_encoded_roundtrip() {
        use crate::memtable::{ColumnData, ColumnarMemtable, DICT_ENCODE_MAX_CARDINALITY};
        use crate::writer::SegmentWriter;

        let schema = ColumnarSchema::new(vec![
            ColumnDef::required("id", ColumnType::Int64).with_primary_key(),
            ColumnDef::required("qtype", ColumnType::String),
        ])
        .expect("valid");

        let qtypes = ["A", "AAAA", "MX", "NS", "SOA", "CNAME", "PTR", "TXT"];
        let mut mt = ColumnarMemtable::new(&schema);
        for (i, &q) in qtypes.iter().cycle().take(100).enumerate() {
            mt.append_row(&[Value::Integer(i as i64), Value::String(q.into())])
                .expect("append");
        }

        // Convert low-cardinality string column to dict-encoded.
        mt.try_dict_encode_columns(DICT_ENCODE_MAX_CARDINALITY);

        // Verify it converted.
        assert!(matches!(mt.columns()[1], ColumnData::DictEncoded { .. }));

        let (schema, columns, row_count) = mt.drain();
        let segment = SegmentWriter::plain()
            .write_segment(&schema, &columns, row_count, None)
            .expect("write segment");

        // Read back.
        let reader = SegmentReader::open(&segment).expect("open");
        assert_eq!(reader.row_count(), 100);

        // The footer should record the dictionary.
        let dict_in_meta = reader.footer().columns[1].dictionary.as_deref();
        assert!(dict_in_meta.is_some(), "dictionary should be in ColumnMeta");
        let meta_dict = dict_in_meta.expect("present");
        assert_eq!(meta_dict.len(), 8, "8 distinct qtypes");

        // Read the qtype column — should come back as DictEncoded.
        let col = reader.read_column(1).expect("read qtype column");
        match col {
            DecodedColumn::DictEncoded {
                ids,
                dictionary,
                valid,
            } => {
                assert_eq!(ids.len(), 100);
                assert_eq!(valid.len(), 100);
                assert!(valid.iter().all(|&v| v));
                assert_eq!(dictionary.len(), 8);

                // Verify round-trip: each row's ID resolves to the original qtype.
                for (i, &q) in qtypes.iter().cycle().take(100).enumerate() {
                    let resolved = &dictionary[ids[i] as usize];
                    assert_eq!(resolved, q, "row {i}: expected {q}, got {resolved}");
                }
            }
            _ => panic!("expected DictEncoded, got {col:?}"),