duckdb::ArrowGeometry Struct Reference

Static Public Member Functions
static unique_ptr< ArrowType >	GetType (ClientContext &context, const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata)
static void	WriteCRS (duckdb_yyjson::yyjson_mut_doc *doc, const CoordinateReferenceSystem &crs, ClientContext &context)
static void	PopulateSchema (DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type, ClientContext &context, const ArrowTypeExtension &extension)
static void	ArrowToDuck (ClientContext &, Vector &source, Vector &result, idx_t count)
static void	DuckToArrow (ClientContext &context, Vector &source, Vector &result, idx_t count)

Member Function Documentation

GetType()

static unique_ptr< ArrowType > duckdb::ArrowGeometry::GetType ( ClientContext &  context, const ArrowSchema &  schema, const ArrowSchemaMetadata &  schema_metadata  )

inlinestatic

                                                                                     {
        // Validate extension metadata. This metadata also contains a CRS, which we drop
        // because the GEOMETRY type does not implement a CRS at the type level (yet).
        const auto extension_metadata = schema_metadata.GetOption(ArrowSchemaMetadata::ARROW_METADATA_KEY);
 
        unique_ptr<CoordinateReferenceSystem> duckdb_crs;
 
        if (!extension_metadata.empty()) {
            unique_ptr<duckdb_yyjson::yyjson_doc, void (*)(duckdb_yyjson::yyjson_doc *)> doc(
                duckdb_yyjson::yyjson_read(extension_metadata.data(), extension_metadata.size(),
                                           duckdb_yyjson::YYJSON_READ_NOFLAG),
                duckdb_yyjson::yyjson_doc_free);
            if (!doc) {
                throw SerializationException("Invalid JSON in GeoArrow metadata");
            }
 
            duckdb_yyjson::yyjson_val *val = yyjson_doc_get_root(doc.get());
            if (!yyjson_is_obj(val)) {
                throw SerializationException("Invalid GeoArrow metadata: not a JSON object");
            }
 
            duckdb_yyjson::yyjson_val *edges = yyjson_obj_get(val, "edges");
            if (edges && yyjson_is_str(edges) && std::strcmp(yyjson_get_str(edges), "planar") != 0) {
                throw NotImplementedException("Can't import non-planar edges");
            }
 
            // Pick out the CRS if present
            duckdb_yyjson::yyjson_val *crs = yyjson_obj_get(val, "crs");
 
            if (crs) {
                if (duckdb_yyjson::yyjson_is_str(crs)) {
                    const char *crs_str = duckdb_yyjson::yyjson_get_str(crs);
                    duckdb_crs = CoordinateReferenceSystem::TryIdentify(context, crs_str);
                } else if (duckdb_yyjson::yyjson_is_obj(crs)) {
                    // Stringify the object
                    duckdb_yyjson::yyjson_write_flag write_flags = duckdb_yyjson::YYJSON_WRITE_NOFLAG;
                    size_t len = 0;
                    const auto crs_str = duckdb_yyjson::yyjson_val_write(crs, write_flags, &len);
                    if (crs_str) {
                        const auto str = string(crs_str, len);
                        free(crs_str);
                        duckdb_crs = CoordinateReferenceSystem::TryIdentify(context, str);
                    } else {
                        throw SerializationException("Could not serialize CRS object from GeoArrow metadata");
                    }
                }
            }
        }
 
        // Create the geometry type, with or without CRS
        auto geo_type = duckdb_crs ? LogicalType::GEOMETRY(*duckdb_crs) : LogicalType::GEOMETRY();
 
        const auto format = string(schema.format);
        if (format == "z") {
            return make_uniq<ArrowType>(std::move(geo_type), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL));
        }
        if (format == "Z") {
            return make_uniq<ArrowType>(std::move(geo_type),
                                        make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE));
        }
        if (format == "vz") {
            return make_uniq<ArrowType>(std::move(geo_type), make_uniq<ArrowStringInfo>(ArrowVariableSizeType::VIEW));
        }
        throw InvalidInputException("Arrow extension type \"%s\" not supported for geoarrow.wkb", format.c_str());
    }

WriteCRS()

static void duckdb::ArrowGeometry::WriteCRS ( duckdb_yyjson::yyjson_mut_doc *  doc, const CoordinateReferenceSystem &  crs, ClientContext &  context  )

inlinestatic

                                                 {
        // Try to convert to preferred formats, in order
        auto converted = CoordinateReferenceSystem::TryConvert(context, crs, CoordinateReferenceSystemType::PROJJSON);
        if (!converted) {
            converted = CoordinateReferenceSystem::TryConvert(context, crs, CoordinateReferenceSystemType::WKT2_2019);
        }
        if (!converted) {
            converted = CoordinateReferenceSystem::TryConvert(context, crs, CoordinateReferenceSystemType::AUTH_CODE);
        }
        if (!converted) {
            converted = CoordinateReferenceSystem::TryConvert(context, crs, CoordinateReferenceSystemType::SRID);
        }
        if (!converted) {
            converted = nullptr;
        }
 
        const auto &crs_def = converted ? converted->GetDefinition() : crs.GetDefinition();
        const auto &crs_type = converted ? converted->GetType() : crs.GetType();
 
        const auto root = duckdb_yyjson::yyjson_mut_doc_get_root(doc);
 
        switch (crs_type) {
        case CoordinateReferenceSystemType::PROJJSON: {
            const auto projjson_doc =
                duckdb_yyjson::yyjson_read(crs_def.c_str(), crs_def.size(), duckdb_yyjson::YYJSON_READ_NOFLAG);
            if (projjson_doc) {
                const auto projjson_val = duckdb_yyjson::yyjson_doc_get_root(projjson_doc);
                const auto projjson_obj = duckdb_yyjson::yyjson_val_mut_copy(doc, projjson_val);
 
                duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs_type", "projjson");
                duckdb_yyjson::yyjson_mut_obj_add_val(doc, root, "crs", projjson_obj);
 
                duckdb_yyjson::yyjson_doc_free(projjson_doc);
            } else {
                duckdb_yyjson::yyjson_mut_doc_free(doc);
                throw SerializationException("Could not parse PROJJSON CRS for GeoArrow metadata");
            }
        } break;
        case CoordinateReferenceSystemType::AUTH_CODE: {
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs_type", "authority_code");
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs", crs_def.c_str());
        } break;
        case CoordinateReferenceSystemType::SRID: {
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs_type", "srid");
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs", crs_def.c_str());
        } break;
        case CoordinateReferenceSystemType::WKT2_2019: {
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs_type", "wkt2:2019");
            duckdb_yyjson::yyjson_mut_obj_add_str(doc, root, "crs", crs_def.c_str());
        } break;
        default:
            throw SerializationException("Could not serialize CRS of type %d for GeoArrow metadata",
                                         static_cast<int>(crs.GetType()));
        }
    }

PopulateSchema()

static void duckdb::ArrowGeometry::PopulateSchema ( DuckDBArrowSchemaHolder &  root_holder, ArrowSchema &  schema, const LogicalType &  type, ClientContext &  context, const ArrowTypeExtension &  extension  )

inlinestatic

                                                                                            {
        ArrowSchemaMetadata schema_metadata;
 
        schema_metadata.AddOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME, "geoarrow.wkb");
 
        // Make a CRS entry if the type has a CRS
        const auto doc = duckdb_yyjson::yyjson_mut_doc_new(nullptr);
        const auto root = duckdb_yyjson::yyjson_mut_obj(doc);
        duckdb_yyjson::yyjson_mut_doc_set_root(doc, root);
 
        if (GeoType::HasCRS(type)) {
            try {
                WriteCRS(doc, GeoType::GetCRS(type), context);
            } catch (...) {
                duckdb_yyjson::yyjson_mut_doc_free(doc);
                throw;
            }
        }
 
        size_t json_size = 0;
        const auto json_text = duckdb_yyjson::yyjson_mut_write(doc, duckdb_yyjson::YYJSON_WRITE_NOFLAG, &json_size);
        if (json_text) {
            schema_metadata.AddOption(ArrowSchemaMetadata::ARROW_METADATA_KEY, json_text);
            duckdb_yyjson::yyjson_mut_doc_free(doc);
            free(json_text);
        } else {
            schema_metadata.AddOption(ArrowSchemaMetadata::ARROW_METADATA_KEY, "{}");
        }
 
        root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata());
        schema.metadata = root_holder.metadata_info.back().get();
 
        const auto options = context.GetClientProperties();
        if (options.arrow_offset_size == ArrowOffsetSize::LARGE) {
            schema.format = "Z";
        } else {
            schema.format = "z";
        }
    }

ArrowToDuck()

static void duckdb::ArrowGeometry::ArrowToDuck ( ClientContext &  , Vector &  source, Vector &  result, idx_t  count  )

inlinestatic

                                                                                          {
        Geometry::FromBinary(source, result, count, true);
    }

DuckToArrow()

static void duckdb::ArrowGeometry::DuckToArrow ( ClientContext &  context, Vector &  source, Vector &  result, idx_t  count  )

inlinestatic

                                                                                                 {
        Geometry::ToBinary(source, result, count);
    }

---

The documentation for this struct was generated from the following file:

• external/duckdb/duckdb.cpp