clean up

db/detail/meta_ops.hpp

@@ -5,7 +5,6 @@
 
 #include <bark/db/meta.hpp>
 #include <bark/detail/grid.hpp>
-#include <bark/detail/unicode.hpp>
 #include <boost/algorithm/cxx11/any_of.hpp>
 #include <boost/range/algorithm/find_if.hpp>
 #include <boost/range/algorithm/search.hpp>
@@ -39,26 +38,23 @@ template <class Indexes, class ColumnNames>
 bool indexed(Indexes&& indexes, ColumnNames&& col_nms)
 {
  return boost::algorithm::any_of(indexes, [&](auto& idx) {
- return boost::range::search(idx.columns,
- col_nms,
- unicode::case_insensitive_equal_to{}) ==
+ return boost::range::search(idx.columns, col_nms) ==
  idx.columns.begin();
  });
 }
 
-template <class Rng>
-auto find(Rng&& rng, std::string_view name)
+template <class Columns>
+auto find(Columns&& cols, std::string_view col_nm)
 {
- return boost::range::find_if(rng, [&](auto& item) {
- return unicode::case_insensitive_equal_to{}(name, item.name);
- });
+ return boost::range::find_if(cols,
+ [=](auto& col) { return col_nm == col.name; });
 }
 
-template <class Rng>
-auto names(Rng&& rng)
+template <class Columns>
+auto names(Columns&& cols)
 {
- return as<std::vector<std::string>>(rng,
- [&](auto& item) { return item.name; });
+ return as<std::vector<std::string>>(cols,
+ [&](auto& col) { return col.name; });
 }
 
 inline geometry::box_rtree make_tiles(size_t count, geometry::box ext)

db/detail/postgres_dialect.hpp

@@ -25,12 +25,13 @@ struct postgres_dialect : dialect {
 
  void columns_sql(sql_builder& bld, const qualified_name& tbl_nm) override
  {
+ auto& tbl = tbl_nm.back();
  auto& scm = tbl_nm.at(-2);
  bld << "SELECT column_name, LOWER(CASE data_type WHEN "
  << param{"USER-DEFINED"}
  << " THEN udt_name ELSE data_type END), numeric_scale FROM "
  "information_schema.columns WHERE table_schema = "
- << param{scm} << " AND table_name = " << param{tbl_nm.back()}
+ << param{scm} << " AND table_name = " << param{tbl}
  << " ORDER BY ordinal_position";
  }
 

db/detail/table_guide.hpp

@@ -68,8 +68,7 @@ class table_guide {
  tbl.columns.push_back(col);
  }
  if (tbl.columns.empty())
- throw std::runtime_error(
- "no columns: " + boost::lexical_cast<std::string>(tbl.name));
+ throw std::runtime_error(concat("no columns: ", tbl.name));
  }
 
  void load_indexes(meta::table& tbl)

db/meta.hpp

@@ -58,9 +58,8 @@ inline std::ostream& operator<<(std::ostream& os, const column& col)
  if (!col.projection.empty())
  opts.push_back(proj::abbreviation(col.projection));
  if (!col.tiles.empty())
- opts.push_back("BOX" +
- boost::lexical_cast<std::string>(
- boost::geometry::dsv(bounds(col.tiles))));
+ opts.push_back(
+ concat("BOX", boost::geometry::dsv(bounds(col.tiles))));
  if (!opts.empty())
  os << " (" << list{opts, ", "} << ")";
  }

db/mysql/command.hpp

@@ -109,7 +109,7 @@ class command : public db::command, private transaction<mysql::command> {
  : nullptr};
  unsigned cols = res ? mysql_num_fields(res.get()) : 0;
 
- std::vector<std::string> names(cols);
+ auto names = std::vector<std::string>(cols);
  binds_.resize(cols);
  memset(binds_.data(), 0, binds_.size() * sizeof(MYSQL_BIND));
  cols_.resize(cols);

db/provider.hpp

@@ -35,7 +35,7 @@ struct provider {
 
  /// Returns a balanced data grid.
 
- /// @param layer is a data set;
+ /// @param layer is a data set identifier;
  /// @param extent is a spatial filter;
  /// @param pixel selects the level of the raster pyramid.
  virtual geometry::multi_box tile_coverage(const qualified_name& layer,
@@ -45,7 +45,7 @@ struct provider {
  /// Returns @ref rowset with spatial data set.
 
  /// Columns @code GEOMETRY[,IMAGE][,ATTRIBUTES...] @endcode
- /// @param layer is a data set;
+ /// @param layer is a data set identifier;
  /// @param extent is a spatial filter;
  /// @param pixel selects the level of the raster pyramid.
  virtual rowset spatial_objects(const qualified_name& layer,
@@ -147,6 +147,13 @@ sql_builder insert_sql(provider& pvd,
  return res;
 };
 
+inline sql_builder insert_sql(provider& pvd,
+ const qualified_name& tbl_nm,
+ const rowset& rows)
+{
+ return insert_sql(pvd, tbl_nm, rows.columns, select(rows));
+}
+
 inline sql_builder drop_sql(provider& pvd, const qualified_name& tbl_nm)
 {
  auto res = builder(pvd);

db/rowset.hpp

@@ -28,19 +28,16 @@ inline auto select(const rowset& from)
 
 /// Returns tuples of @ref variant_t
 template <class Columns>
-auto select(const Columns& columns, const rowset& from)
+auto select(const Columns& cols, const rowset& from)
 {
- auto cols = as<std::vector<std::string>>(
- columns, [](const auto& col) { return unicode::to_lower(col); });
-
- auto idxs = as<std::vector<size_t>>(from.columns, [&](const auto& col) {
- auto it = std::find(cols.begin(), cols.end(), unicode::to_lower(col));
- return std::distance(cols.begin(), it);
+ auto idxs = as<std::vector<size_t>>(from.columns, [&](auto&& col) {
+ auto it = std::find(std::begin(cols), std::end(cols), col);
+ return std::distance(std::begin(cols), it);
  });
 
  auto res = std::vector<std::vector<variant_t>>{};
  for (auto is = variant_istream{from.data}; !is.data.empty();) {
- auto& row = res.emplace_back(cols.size());
+ auto& row = res.emplace_back(idxs.size());
  for (size_t idx : idxs)
  if (idx < row.size())
  is >> row[idx];

detail/lru_cache.hpp

@@ -44,7 +44,7 @@ class lru_cache {
  auto res = mapped_type::result_of(std::forward<F>(f),
  std::forward<Args>(args)...);
  insert({scoped_key, res});
- return res.get();
+ return std::move(res).get();
  }
 
  template <class Key>

detail/unicode.hpp

@@ -79,14 +79,6 @@ auto to_upper(const Str& str)
  return unicode::to_string<range_value_t<Str>>(wstr);
 }
 
-struct case_insensitive_equal_to {
- template <class Lhs, class Rhs>
- bool operator()(const Lhs& lhs, const Rhs& rhs) const
- {
- return to_lower(lhs) == to_lower(rhs);
- }
-};
-
 } // namespace bark::unicode
 
 #endif // BARK_UNICODE_HPP

detail/utility.hpp

@@ -133,32 +133,31 @@ constexpr size_t variant_index()
 /// expected<T> is either a T or the exception preventing its creation.
 template <class T>
 class expected {
+ std::variant<std::exception_ptr, T> val_;
+
 public:
  template <class F, class... Args>
  static expected result_of(F&& f, Args&&... args) noexcept
  {
  expected res;
  try {
- res.state_ =
+ res.val_ =
  std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
  }
- catch (const std::exception&) {
- res.state_ = std::current_exception();
+ catch (...) {
+ res.val_ = std::current_exception();
  }
  return res;
  }
 
- T get()
+ T get() &&
  {
- return std::visit(overloaded{[](T& val) -> T { return std::move(val); },
-  [](std::exception_ptr& e) -> T {
-  std::rethrow_exception(std::move(e));
-   }},
-  state_);
+ return std::visit(
+ overloaded{
+ [](std::exception_ptr e) -> T { std::rethrow_exception(e); },
+ [](T&& val) -> T { return std::move(val); }},
+ std::move(val_));
  }
-
-private:
- std::variant<std::exception_ptr, T> state_;
 };
 
 /// Joins 'items' by adding user defined separator.
@@ -240,6 +239,11 @@ streamable(T) -> streamable<T>;
 /// @see https://en.cppreference.com/w/cpp/named_req/TimedLockable
 template <class T, class Hash = std::hash<T>, class Equal = std::equal_to<T>>
 class timed_lockable {
+ T val_;
+ inline static std::mutex guard_;
+ inline static std::condition_variable notifier_;
+ inline static std::unordered_set<T, Hash, Equal> locked_;
+
 public:
  explicit timed_lockable(const T& val) : val_{val} {}
 
@@ -260,12 +264,6 @@ class timed_lockable {
  }
  notifier_.notify_all();
  }
-
-private:
- T val_;
- inline static std::mutex guard_;
- inline static std::condition_variable notifier_;
- inline static std::unordered_set<T, Hash, Equal> locked_;
 };
 
 } // namespace bark