column_expression.hpp

Go to the documentation of this file.

#pragma once
 
#include "core.hpp"
 
#include <iostream>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
namespace relx::query {
 
// Forward declarations
class CaseExpr;
 
class ColumnExpression : public SqlExpression {
public:
  virtual ~ColumnExpression() = default;
  virtual std::string column_name() const = 0;
  virtual std::string table_name() const = 0;
  virtual std::string qualified_name() const {
    std::string qualified = column_name();
    auto table = table_name();
    if (!table.empty()) {
      qualified = table + "." + qualified;
    }
    return qualified;
  }
};
 
template <ColumnType Column>
class ColumnRef : public ColumnExpression {
public:
  using column_type = Column;
  using value_type = typename Column::value_type;
 
  explicit ColumnRef(const Column& col) : col_(col) {}
 
  std::string to_sql() const override { return qualified_name(); }
 
  std::vector<std::string> bind_params() const override { return {}; }
 
  std::string column_name() const override { return std::string(Column::name); }
 
  std::string table_name() const override {
    // Get the table name from the parent table class
    using parent_table = typename Column::table_type;
    return std::string(parent_table::table_name);
  }
 
  const Column& column() const { return col_; }
 
private:
  const Column& col_;
};
 
template <ColumnType Column>
auto column_ref(const Column& col) {
  return ColumnRef<Column>(col);
}
 
template <SqlExpr Expr>
class AliasedColumn : public ColumnExpression {
public:
  AliasedColumn(const Expr& expr, std::string alias)
      : expr_(std::make_shared<Expr>(expr)), alias_(std::move(alias)) {}
 
  AliasedColumn(Expr&& expr, std::string alias)
      : expr_(std::make_shared<Expr>(std::move(expr))), alias_(std::move(alias)) {}
 
  // Special constructor for non-copyable types
  AliasedColumn(std::shared_ptr<Expr> expr, std::string alias)
      : expr_(std::move(expr)), alias_(std::move(alias)) {}
 
  std::string to_sql() const override { return expr_->to_sql() + " AS " + alias_; }
 
  std::vector<std::string> bind_params() const override { return expr_->bind_params(); }
 
  std::string column_name() const override { return alias_; }
 
  std::string table_name() const override { return ""; }
 
private:
  std::shared_ptr<Expr> expr_;
  std::string alias_;
};
 
template <SqlExpr Expr>
auto as(const Expr& expr, std::string alias) {
  return AliasedColumn<Expr>(expr, std::move(alias));
}
 
template <ColumnType Column>
auto as(const Column& column, std::string alias) {
  return AliasedColumn<ColumnRef<Column>>(column_ref(column), std::move(alias));
}
 
}  // namespace relx::query