/**

* SPDX-License-Identifier: GPL-2.0-or-later

*

* This file is part of osm2pgsql (https://osm2pgsql.org/).

*

* Copyright (C) 2006-2026 by the osm2pgsql developer community.

* For a full list of authors see the git log.

*/

#include "command-line-parser.hpp"

#include "input.hpp"

#include "logging.hpp"

#include "middle.hpp"

#include "options.hpp"

#include "osmdata.hpp"

#include "output.hpp"

#include "pgsql.hpp"

#include "pgsql-capabilities.hpp"

#include "properties.hpp"

#include "util.hpp"

#include "version.hpp"

#include <osmium/util/memory.hpp>

#include <exception>

#include <filesystem>

#include <memory>

#include <string>

#include <utility>

namespace {

/**

* Output overall memory usage as debug message.

*

* This only works on Linux.

*/

void show_memory_usage()

{

osmium::MemoryUsage const mem;

if (mem.peak() != 0) {

log_debug("Overall memory usage: peak={}MByte current={}MByte",

mem.peak(), mem.current());

}

}

file_info run(options_t const &options, properties_t *properties)

{

auto const files = prepare_input_files(

options.input_files, options.input_format, options.append);

auto thread_pool = std::make_shared<thread_pool_t>(

options.parallel_indexing ? options.num_procs : 1U);

log_debug("Started pool with {} threads.", thread_pool->num_threads());

auto middle = create_middle(thread_pool, options);

middle->start();

auto output = output_t::create_output(middle->get_query_instance(),

thread_pool, options, *properties);

middle->set_requirements(output->get_requirements());

if (!options.append) {

properties->init_table();

}

properties->store();

osmdata_t osmdata{middle, output, options};

// Processing: In this phase the input file(s) are read and parsed,

// populating some of the tables.

auto finfo = process_files(files, &osmdata, options.append,

get_logger().show_progress());

show_memory_usage();

// Process pending ways and relations. Cluster database tables and

// create indexes.

osmdata.stop();

return finfo;

}

void check_db(options_t const &options)

{

pg_conn_t const db_connection{options.connection_params, "check"};

init_database_capabilities(db_connection);

auto const pv = get_postgis_version();

if (pv.major < 3) {

throw std::runtime_error{"Need at least PostGIS version 3.0"};

}

check_schema(options.dbschema);

check_schema(options.middle_dbschema);

check_schema(options.output_dbschema);

}

// This is called in "create" mode to initialize properties.

void set_up_properties(properties_t *properties, options_t const &options)

{

properties->set_bool("attributes", options.extra_attributes);

if (options.flat_node_file.empty()) {

properties->set_string("flat_node_file", "");

} else {

properties->set_string(

"flat_node_file", std::filesystem::absolute(

std::filesystem::path{options.flat_node_file})

.string());

}

properties->set_string("prefix", options.prefix);

properties->set_bool("updatable", options.slim && !options.droptemp);

properties->set_string("version", get_osm2pgsql_short_version());

properties->set_int("db_format", options.middle_database_format);

properties->set_string("output", options.output_backend);

if (options.style.empty()) {

properties->set_string("style", "");

} else {

properties->set_string(

"style",

std::filesystem::absolute(std::filesystem::path{options.style})

.string());

}

}

void store_data_properties(properties_t *properties, file_info const &finfo)

{

if (finfo.last_timestamp.valid()) {

auto const timestamp = finfo.last_timestamp.to_iso();

properties->set_string("import_timestamp", timestamp);

properties->set_string("current_timestamp", timestamp);

}

for (std::string const s : {"base_url", "sequence_number", "timestamp"}) {

auto const value = finfo.header.get("osmosis_replication_" + s);

if (!value.empty()) {

properties->set_string("replication_" + s, value);

}

}

}

void check_updatable(properties_t const &properties)

{

if (properties.get_bool("updatable", false)) {

return;

}

throw std::runtime_error{

"This database is not updatable. To create an"

" updatable database use --slim (without --drop)."};

}

void check_attributes(properties_t const &properties, options_t *options)

{

bool const with_attributes = properties.get_bool("attributes", false);

if (options->extra_attributes) {

if (!with_attributes) {

throw std::runtime_error{

"Can not update with attributes (-x/--extra-attributes)"

" because original import was without attributes."};

}

return;

}

if (with_attributes) {

log_info("Updating with attributes (same as on import).");

options->extra_attributes = true;

}

}

void check_and_update_flat_node_file(properties_t *properties,

options_t *options)

{

auto const flat_node_file_from_import =

properties->get_string("flat_node_file", "");

if (options->flat_node_file.empty()) {

if (flat_node_file_from_import.empty()) {

log_info("Not using flat node file (same as on import).");

} else {

options->flat_node_file = flat_node_file_from_import;

log_info("Using flat node file '{}' (same as on import).",

flat_node_file_from_import);

}

} else {

auto const absolute_path =

std::filesystem::absolute(

std::filesystem::path{options->flat_node_file})

.string();

if (flat_node_file_from_import.empty()) {

throw fmt_error("Database was imported without flat node file. Can"

" not use flat node file '{}' now.",

options->flat_node_file);

}

if (absolute_path == flat_node_file_from_import) {

log_info("Using flat node file '{}' (same as on import).",

flat_node_file_from_import);

} else {

log_info(

"Using the flat node file you specified on the command line"

" ('{}') instead of the one used on import ('{}').",

absolute_path, flat_node_file_from_import);

properties->set_string("flat_node_file", absolute_path);

}

}

}

void check_prefix(properties_t const &properties, options_t *options)

{

auto const prefix = properties.get_string("prefix", "planet_osm");

if (!options->prefix_is_set) {

log_info("Using prefix '{}' (same as on import).", prefix);

options->prefix = prefix;

return;

}

if (prefix != options->prefix) {

throw fmt_error("Different prefix specified on command line ('{}')"

" then used on import ('{}').",

options->prefix, prefix);

}

}

void check_db_format(properties_t const &properties, options_t *options)

{

auto const format = properties.get_int("db_format", -1);

if (format == 1) {

throw std::runtime_error{

"Old database format detected. This version of osm2pgsql can not "

"read this any more. Downgrade osm2pgsql or reimport database."};

}

if (format != 2) {

throw fmt_error("Unknown db_format '{}' in properties.", format);

}

options->middle_database_format = static_cast<uint8_t>(format);

}

void check_output(properties_t const &properties, options_t *options)

{

auto const output = properties.get_string("output", "pgsql");

if (options->output_backend.empty()) {

options->output_backend = output;

log_info("Using output '{}' (same as on import).", output);

return;

}

if (options->output_backend == output) {

return;

}

throw fmt_error("Different output specified on command line ('{}')"

" then used on import ('{}').",

options->output_backend, output);

}

void check_and_update_style_file(properties_t *properties, options_t *options)

{

auto const style_file_from_import = properties->get_string("style", "");

if (options->style.empty()) {

log_info("Using style file '{}' (same as on import).",

style_file_from_import);

options->style = style_file_from_import;

return;

}

if (style_file_from_import.empty()) {

throw std::runtime_error{"Style file from import is empty!?"};

}

auto const absolute_path =

std::filesystem::absolute(std::filesystem::path{options->style})

.string();

if (absolute_path == style_file_from_import) {

log_info("Using style file '{}' (same as on import).",

style_file_from_import);

return;

}

log_info("Using the style file you specified on the command line"

" ('{}') instead of the one used on import ('{}').",

absolute_path, style_file_from_import);

properties->set_string("style", absolute_path);

}

// This is called in "append" mode to check that the command line options are

// compatible with the properties stored in the database.

void check_and_update_properties(properties_t *properties, options_t *options)

{

check_updatable(*properties);

check_attributes(*properties, options);

check_and_update_flat_node_file(properties, options);

check_prefix(*properties, options);

check_db_format(*properties, options);

check_output(*properties, options);

check_and_update_style_file(properties, options);

}

void set_option_defaults(options_t *options)

{

if (options->output_backend.empty()) {

options->output_backend = "pgsql";

}

if (options->style.empty()) {

if (options->output_backend == "flex") {

throw std::runtime_error{"You have to set the config file "

"with the -S|--style option."};

}

if (options->output_backend == "pgsql") {

options->style = DEFAULT_STYLE;

}

}

}

} // anonymous namespace

// NOLINTNEXTLINE(bugprone-exception-escape)

int main(int argc, char *argv[])

{

try {

auto options = parse_command_line(argc, argv);

if (options.command == command_t::help) {

// Already handled inside parse_command_line()

return 0;

}

if (options.command == command_t::version) {

print_version("osm2pgsql");

return 0;

}

util::timer_t timer_overall;

check_db(options);

properties_t properties{options.connection_params,

options.middle_dbschema};

if (options.append) {

if (!properties.load()) {

throw std::runtime_error{

"Did not find table 'osm2pgsql_properties' in database. "

"Database too old? Wrong schema?"};

}

check_and_update_properties(&properties, &options);

properties.store();

auto const finfo = run(options, &properties);

if (finfo.last_timestamp.valid()) {

auto const current_timestamp =

properties.get_string("current_timestamp", "");

if (current_timestamp.empty() ||

(finfo.last_timestamp >

osmium::Timestamp{current_timestamp})) {

properties.set_string("current_timestamp",

finfo.last_timestamp.to_iso());

}

}

} else {

set_option_defaults(&options);

set_up_properties(&properties, options);

auto const finfo = run(options, &properties);

store_data_properties(&properties, finfo);

}

properties.store();

show_memory_usage();

log_info("osm2pgsql took {} overall.",

util::human_readable_duration(timer_overall.stop()));

} catch (std::exception const &e) {

log_error("{}", e.what());

return 1;

} catch (...) {

log_error("Unknown exception.");

return 1;

}

return 0;

}