import_export::anonymous_namespace{QueryExporterGDAL.cpp} Namespace Reference

Functions
OGRFieldType	sql_type_info_to_ogr_field_type (const std::string &name, const SQLTypeInfo &type_info, const QueryExporter::FileType file_type)
void	insert_geo_column (const GeoTargetValue *geo_tv, const SQLTypeInfo &ti, const int field_index, OGRFeature *ogr_feature)
void	insert_scalar_column (const ScalarTargetValue *scalar_tv, const SQLTypeInfo &ti, const int field_index, OGRFeature *ogr_feature)
void	insert_array_column (const ArrayTargetValue *array_tv, const SQLTypeInfo &ti, const int field_index, OGRFeature *ogr_feature, const std::string &column_name, QueryExporter::ArrayNullHandling array_null_handling)

Variables
static constexpr std::array < const char *, 5 >	driver_names
static constexpr std::array < const char *, 5 >	file_type_names
static constexpr std::array < const char *, 3 >	compression_prefix
static constexpr std::array < const char *, 3 >	compression_suffix = {"", ".gz", ".zip"}
static constexpr std::array < std::array< bool, 3 >, 5 >	compression_implemented
static std::array < std::unordered_set < std::string >, 5 >	file_type_valid_extensions

Function Documentation

void import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_array_column	(	const ArrayTargetValue *	array_tv,
		const SQLTypeInfo &	ti,
		const int	field_index,
		OGRFeature *	ogr_feature,
		const std::string &	column_name,
		QueryExporter::ArrayNullHandling	array_null_handling
	)

Definition at line 481 of file QueryExporterGDAL.cpp.

References CHECK, CHECK_EQ, CHECK_GE, shared::convert_temporal_to_iso_format(), SQLTypeInfo::get_elem_type(), SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type_name(), SQLTypeInfo::is_geometry(), is_null(), SQLTypeInfo::is_time(), import_export::QueryExporter::kAbortWithWarning, kBIGINT, kBOOLEAN, kDATE, import_export::QueryExporter::kExportZeros, kFLOAT, kINT, import_export::QueryExporter::kNullEntireField, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, and NULL_TINYINT.

Referenced by import_export::QueryExporterGDAL::exportResults().

                                                                             {
  CHECK_GE(field_index, 0);
  CHECK(!ti.is_geometry());

  if (!array_tv->is_initialized()) {
    // entire array is null
    ogr_feature->SetFieldNull(field_index);
    return;
  }

  auto const& scalar_tvs = array_tv->get();

  auto field_type = ogr_feature->GetFieldDefnRef(field_index)->GetType();

  // only one of these will get used
  // could use a std::vector<ScalarTargetValue> but need raw data at the end
  // so we would have to extract it there anyway, so not sure it's worthwhile
  // we can, at least, pre-reserve whichever array we're going to use
  std::vector<int> int_values;
  std::vector<GIntBig> int64_values;
  std::vector<std::string> string_values;
  std::vector<double> real_values;
  switch (field_type) {
    case OFTIntegerList:
      int_values.reserve(scalar_tvs.size());
      break;
    case OFTInteger64List:
      int64_values.reserve(scalar_tvs.size());
      break;
    case OFTRealList:
      real_values.reserve(scalar_tvs.size());
      break;
    case OFTStringList:
      string_values.reserve(scalar_tvs.size());
      break;
    default:
      CHECK(false);
  }

  bool force_null_to_zero =
      (array_null_handling == QueryExporter::ArrayNullHandling::kExportZeros);

  // now extract the data
  bool any_null = false;
  for (uint32_t i = 0; i < scalar_tvs.size(); i++) {
    bool is_null = false;
    auto const scalar_tv = &scalar_tvs[i];
    if (boost::get<int64_t>(scalar_tv)) {
      auto int_val = *(boost::get<int64_t>(scalar_tv));
      bool is_int64 = false;
      switch (ti.get_subtype()) {
        case kBOOLEAN:
          is_null = (int_val == NULL_BOOLEAN);
          break;
        case kTINYINT:
          is_null = (int_val == NULL_TINYINT);
          break;
        case kSMALLINT:
          is_null = (int_val == NULL_SMALLINT);
          break;
        case kINT:
          is_null = (int_val == NULL_INT);
          break;
        case kBIGINT:
          is_null = (int_val == NULL_BIGINT);
          is_int64 = true;
          break;
        case kTIME:
        case kTIMESTAMP:
        case kDATE:
          is_null = (int_val == NULL_BIGINT);
          is_int64 = true;
          break;
        default:
          is_null = false;
      }
      if (ti.get_elem_type().is_time()) {
        if (is_null) {
          string_values.emplace_back("");
        } else {
          string_values.emplace_back(
              shared::convert_temporal_to_iso_format(ti.get_elem_type(), int_val));
        }
      } else if (is_int64) {
        if (is_null && force_null_to_zero) {
          int64_values.push_back(0);
        } else {
          int64_values.push_back(int_val);
        }
      } else {
        if (is_null && force_null_to_zero) {
          int_values.push_back(0);
        } else {
          int_values.push_back(int_val);
        }
      }
    } else if (boost::get<double>(scalar_tv)) {
      auto real_val = *(boost::get<double>(scalar_tv));
      if (ti.get_subtype() == kFLOAT) {
        is_null = (real_val == NULL_FLOAT);
      } else {
        is_null = (real_val == NULL_DOUBLE);
      }
      if (is_null && force_null_to_zero) {
        real_values.push_back(0.0);
      } else {
        real_values.push_back(real_val);
      }
    } else if (boost::get<float>(scalar_tv)) {
      CHECK_EQ(kFLOAT, ti.get_subtype());
      auto real_val = *(boost::get<float>(scalar_tv));
      is_null = (real_val == NULL_FLOAT);
      if (is_null && force_null_to_zero) {
        real_values.push_back(0.0);
      } else {
        real_values.push_back(static_cast<double>(real_val));
      }
    } else {
      auto s = boost::get<NullableString>(scalar_tv);
      is_null = !s || boost::get<void*>(s);
      if (is_null) {
        string_values.emplace_back("");
      } else {
        auto s_notnull = boost::get<std::string>(s);
        CHECK(s_notnull);
        string_values.emplace_back(s_notnull->c_str());
      }
    }
    any_null |= is_null;
  }

  // special behaviour if we found any individual nulls?
  if (any_null) {
    switch (array_null_handling) {
      case QueryExporter::ArrayNullHandling::kAbortWithWarning:
        throw std::runtime_error(
            "Found individual nulls in Array Column '" + column_name + "' of type '" +
            ti.get_type_name() +
            "'. Use 'array_null_handling' Export Option to specify behaviour.");
      case QueryExporter::ArrayNullHandling::kNullEntireField:
        ogr_feature->SetFieldNull(field_index);
        return;
      default:
        break;
    }
  }

  // store the captured array in the feature
  switch (field_type) {
    case OFTIntegerList:
      ogr_feature->SetField(field_index, int_values.size(), int_values.data());
      break;
    case OFTInteger64List:
      ogr_feature->SetField(field_index, int64_values.size(), int64_values.data());
      break;
    case OFTRealList:
      ogr_feature->SetField(field_index, real_values.size(), real_values.data());
      break;
    case OFTStringList: {
      std::vector<const char*> raw_strings;
      raw_strings.reserve(string_values.size() + 1);
      for (auto const& string_value : string_values) {
        raw_strings.push_back(string_value.c_str());
      }
      raw_strings.push_back(nullptr);
      ogr_feature->SetField(field_index, raw_strings.data());
    } break;
    default:
      CHECK(false);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_geo_column	(	const GeoTargetValue *	geo_tv,
		const SQLTypeInfo &	ti,
		const int	field_index,
		OGRFeature *	ogr_feature
	)

Definition at line 327 of file QueryExporterGDAL.cpp.

References CHECK, CHECK_EQ, SQLTypeInfo::get_type(), Geospatial::GeoBase::getOGRGeometry(), SQLTypeInfo::is_geometry(), kLINESTRING, kMULTILINESTRING, kMULTIPOINT, kMULTIPOLYGON, kPOINT, and kPOLYGON.

Referenced by import_export::QueryExporterGDAL::exportResults().

                                                {
  CHECK_EQ(field_index, -1);
  CHECK(ti.is_geometry());

  // use Geo classes to convert to OGRGeometry
  // and destroy when Geo object goes out of scope
  switch (ti.get_type()) {
    case kPOINT: {
      auto const point_tv = boost::get<GeoPointTargetValue>(geo_tv->get());
      auto* coords = point_tv.coords.get();
      CHECK(coords);
      Geospatial::GeoPoint point(*coords);
      ogr_feature->SetGeometry(point.getOGRGeometry());
    } break;
    case kMULTIPOINT: {
      auto const multipoint_tv = boost::get<GeoMultiPointTargetValue>(geo_tv->get());
      auto* coords = multipoint_tv.coords.get();
      CHECK(coords);
      Geospatial::GeoMultiPoint multipoint(*coords);
      ogr_feature->SetGeometry(multipoint.getOGRGeometry());
    } break;
    case kLINESTRING: {
      auto const linestring_tv = boost::get<GeoLineStringTargetValue>(geo_tv->get());
      auto* coords = linestring_tv.coords.get();
      CHECK(coords);
      Geospatial::GeoLineString linestring(*coords);
      ogr_feature->SetGeometry(linestring.getOGRGeometry());
    } break;
    case kMULTILINESTRING: {
      auto const multilinestring_tv =
          boost::get<GeoMultiLineStringTargetValue>(geo_tv->get());
      auto* coords = multilinestring_tv.coords.get();
      CHECK(coords);
      auto* linestring_sizes = multilinestring_tv.linestring_sizes.get();
      CHECK(linestring_sizes);
      Geospatial::GeoMultiLineString multilinestring(*coords, *linestring_sizes);
      ogr_feature->SetGeometry(multilinestring.getOGRGeometry());
    } break;
    case kPOLYGON: {
      auto const polygon_tv = boost::get<GeoPolyTargetValue>(geo_tv->get());
      auto* coords = polygon_tv.coords.get();
      CHECK(coords);
      auto* ring_sizes = polygon_tv.ring_sizes.get();
      CHECK(ring_sizes);
      Geospatial::GeoPolygon polygon(*coords, *ring_sizes);
      ogr_feature->SetGeometry(polygon.getOGRGeometry());
    } break;
    case kMULTIPOLYGON: {
      auto const multipolygon_tv = boost::get<GeoMultiPolyTargetValue>(geo_tv->get());
      auto* coords = multipolygon_tv.coords.get();
      CHECK(coords);
      auto* ring_sizes = multipolygon_tv.ring_sizes.get();
      CHECK(ring_sizes);
      auto* poly_rings = multipolygon_tv.poly_rings.get();
      CHECK(poly_rings);
      Geospatial::GeoMultiPolygon multipolygon(*coords, *ring_sizes, *poly_rings);
      ogr_feature->SetGeometry(multipolygon.getOGRGeometry());
    } break;
    default:
      CHECK(false);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void import_export::anonymous_namespace{QueryExporterGDAL.cpp}::insert_scalar_column	(	const ScalarTargetValue *	scalar_tv,
		const SQLTypeInfo &	ti,
		const int	field_index,
		OGRFeature *	ogr_feature
	)

Definition at line 393 of file QueryExporterGDAL.cpp.

References CHECK, CHECK_EQ, CHECK_GE, shared::convert_temporal_to_iso_format(), SQLTypeInfo::get_type(), SQLTypeInfo::is_geometry(), is_null(), SQLTypeInfo::is_time(), kBIGINT, kBOOLEAN, kDATE, kFLOAT, kINT, kSMALLINT, kTIME, kTIMESTAMP, kTINYINT, NULL_BIGINT, NULL_BOOLEAN, NULL_DOUBLE, NULL_FLOAT, NULL_INT, NULL_SMALLINT, NULL_TINYINT, and SCI.

Referenced by import_export::QueryExporterGDAL::exportResults().

                                                   {
  CHECK_GE(field_index, 0);
  CHECK(!ti.is_geometry());

  auto field_type = ogr_feature->GetFieldDefnRef(field_index)->GetType();

  bool is_null{false};
  if (boost::get<int64_t>(scalar_tv)) {
    auto int_val = *(boost::get<int64_t>(scalar_tv));
    bool is_int64 = false;
    switch (ti.get_type()) {
      case kBOOLEAN:
        is_null = (int_val == NULL_BOOLEAN);
        break;
      case kTINYINT:
        is_null = (int_val == NULL_TINYINT);
        break;
      case kSMALLINT:
        is_null = (int_val == NULL_SMALLINT);
        break;
      case kINT:
        is_null = (int_val == NULL_INT);
        break;
      case kBIGINT:
        is_null = (int_val == NULL_BIGINT);
        is_int64 = true;
        break;
      case kTIME:
      case kTIMESTAMP:
      case kDATE:
        is_null = (int_val == NULL_BIGINT);
        is_int64 = true;
        break;
      default:
        is_null = false;
    }
    if (is_null) {
      ogr_feature->SetFieldNull(field_index);
    } else if (ti.is_time()) {
      CHECK_EQ(field_type, OFTString);
      auto str = shared::convert_temporal_to_iso_format(ti, int_val);
      ogr_feature->SetField(field_index, str.c_str());
    } else if (is_int64) {
      CHECK_EQ(field_type, OFTInteger64);
      ogr_feature->SetField(field_index, static_cast<GIntBig>(int_val));
    } else {
      CHECK_EQ(field_type, OFTInteger);
      ogr_feature->SetField(field_index, SCI(int_val));
    }
  } else if (boost::get<double>(scalar_tv)) {
    auto real_val = *(boost::get<double>(scalar_tv));
    if (ti.get_type() == kFLOAT) {
      is_null = (real_val == NULL_FLOAT);
    } else {
      is_null = (real_val == NULL_DOUBLE);
    }
    if (is_null) {
      ogr_feature->SetFieldNull(field_index);
    } else {
      CHECK_EQ(field_type, OFTReal);
      ogr_feature->SetField(field_index, real_val);
    }
  } else if (boost::get<float>(scalar_tv)) {
    CHECK_EQ(kFLOAT, ti.get_type());
    auto real_val = *(boost::get<float>(scalar_tv));
    if (real_val == NULL_FLOAT) {
      ogr_feature->SetFieldNull(field_index);
    } else {
      CHECK_EQ(field_type, OFTReal);
      ogr_feature->SetField(field_index, real_val);
    }
  } else {
    auto s = boost::get<NullableString>(scalar_tv);
    is_null = !s || boost::get<void*>(s);
    if (is_null) {
      ogr_feature->SetFieldNull(field_index);
    } else {
      CHECK_EQ(field_type, OFTString);
      auto s_notnull = boost::get<std::string>(s);
      CHECK(s_notnull);
      ogr_feature->SetField(field_index, s_notnull->c_str());
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

OGRFieldType import_export::anonymous_namespace{QueryExporterGDAL.cpp}::sql_type_info_to_ogr_field_type	(	const std::string &	name,
		const SQLTypeInfo &	type_info,
		const QueryExporter::FileType	file_type
	)

Definition at line 94 of file QueryExporterGDAL.cpp.

References SQLTypeInfo::get_subtype(), SQLTypeInfo::get_type(), SQLTypeInfo::get_type_name(), kARRAY, kBIGINT, kBOOLEAN, kCHAR, kDATE, kDECIMAL, kDOUBLE, import_export::QueryExporter::kFlatGeobuf, kFLOAT, kINT, kINTERVAL_DAY_TIME, kINTERVAL_YEAR_MONTH, kNUMERIC, import_export::QueryExporter::kShapefile, kSMALLINT, kTEXT, kTIME, kTIMESTAMP, kTINYINT, kVARCHAR, and SCI.

Referenced by import_export::QueryExporterGDAL::beginExport().

                                                                                    {
  // store BOOLEAN as int
  // store TIME as string (no OFTTimeList and Shapefiles reject OFTTime anyway)
  // store all other time/date types as int64
  // Shapefiles cannot store arrays of any type
  switch (type_info.get_type()) {
    case kBOOLEAN:
    case kTINYINT:
    case kINT:
    case kSMALLINT:
      return OFTInteger;
    case kFLOAT:
    case kDOUBLE:
    case kNUMERIC:
    case kDECIMAL:
      return OFTReal;
    case kCHAR:
    case kVARCHAR:
    case kTEXT:
    case kTIME:
    case kTIMESTAMP:
    case kDATE:
      return OFTString;
    case kBIGINT:
    case kINTERVAL_DAY_TIME:
    case kINTERVAL_YEAR_MONTH:
      return OFTInteger64;
    case kARRAY:
      if (file_type != QueryExporter::FileType::kShapefile &&
          file_type != QueryExporter::FileType::kFlatGeobuf) {
        switch (type_info.get_subtype()) {
          case kBOOLEAN:
          case kTINYINT:
          case kINT:
          case kSMALLINT:
            return OFTIntegerList;
          case kFLOAT:
          case kDOUBLE:
          case kNUMERIC:
          case kDECIMAL:
            return OFTRealList;
          case kCHAR:
          case kVARCHAR:
          case kTEXT:
          case kTIME:
          case kTIMESTAMP:
          case kDATE:
            return OFTStringList;
          case kBIGINT:
          case kINTERVAL_DAY_TIME:
          case kINTERVAL_YEAR_MONTH:
            return OFTInteger64List;
          default:
            break;
        }
      }
      break;
    default:
      break;
  }
  throw std::runtime_error("Column '" + name + "' has unsupported type '" +
                           type_info.get_type_name() + "' for file type '" +
                           file_type_names[SCI(file_type)] + "'");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

constexpr std::array<std::array<bool, 3>, 5> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::compression_implemented

static

Initial value:

= {
    {{true, false, false},    
     {true, true, false},     
     {true, true, false},     
     {true, false, false},    
     {true, false, false}}}

Definition at line 84 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().

constexpr std::array<const char*, 3> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::compression_prefix

static

Initial value:

= {"",
                                                                  "/vsigzip/",
                                                                  "/vsizip/"}

Definition at line 76 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().

constexpr std::array<const char*, 3> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::compression_suffix = {"", ".gz", ".zip"}

static

Definition at line 80 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().

constexpr std::array<const char*, 5> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::driver_names

static

Initial value:

= {"INVALID",
                                                            "GeoJSON",
                                                            "GeoJSONSeq",
                                                            "ESRI Shapefile",
                                                            "FlatGeobuf"}

Definition at line 64 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().

constexpr std::array<const char*, 5> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::file_type_names

static

Initial value:

= {"CSV",
                                                               "GeoJSON",
                                                               "GeoJSONL",
                                                               "Shapefile",
                                                               "FlatGeobuf"}

Definition at line 70 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().

std::array<std::unordered_set<std::string>, 5> import_export::anonymous_namespace{QueryExporterGDAL.cpp}::file_type_valid_extensions

static

Initial value:

= {
    {{".csv", ".tsv"}, {".geojson", ".json"}, {".geojson", ".json"}, {".shp"}, {".fgb"}}}

Definition at line 91 of file QueryExporterGDAL.cpp.

Referenced by import_export::QueryExporterGDAL::beginExport().