1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
//===----------------------------------------------------------------------===//
// DuckDB
//
// shell_renderer.hpp
//
//
//===----------------------------------------------------------------------===//
#pragma once
#include "shell_state.hpp"
#include "shell_highlight.hpp"
namespace duckdb_shell {
struct ShellState;
struct RenderingResultIterator;
struct ResultMetadata {
explicit ResultMetadata(duckdb::QueryResult &result);
vector<string> column_names;
vector<duckdb::LogicalType> types;
vector<string> type_names;
idx_t ColumnCount() const {
return column_names.size();
}
};
struct RowData {
vector<duckdb::string_t> data;
vector<bool> is_null;
idx_t row_index = 0;
};
struct RenderingQueryResult {
RenderingQueryResult(duckdb::QueryResult &result, ShellRenderer &renderer);
duckdb::QueryResult &result;
ShellRenderer &renderer;
ResultMetadata metadata;
vector<unique_ptr<duckdb::DataChunk>> chunks;
bool exhausted_result = false;
idx_t loaded_row_count = 0;
idx_t ColumnCount() const {
return metadata.ColumnCount();
}
bool TryConvertChunk();
public:
RenderingResultIterator begin(); // NOLINT: match stl API
RenderingResultIterator end(); // NOLINT: match stl API
};
enum class TextAlignment { CENTER, LEFT, RIGHT };
struct PrintStream {
public:
explicit PrintStream(ShellState &state);
virtual ~PrintStream() = default;
virtual void Print(const string &str) {
state.Print(str);
}
virtual void Print(duckdb::string_t str) {
state.Print(str);
}
virtual void Print(const char *str) {
state.Print(str);
}
virtual void SetBinaryMode() {
state.SetBinaryMode();
}
virtual void SetTextMode() {
state.SetTextMode();
}
virtual bool SupportsHighlight() {
return true;
}
void RenderAlignedValue(const string &str, idx_t width, TextAlignment alignment = TextAlignment::CENTER);
void RenderAlignedValue(const char *str, idx_t str_len, idx_t width,
TextAlignment alignment = TextAlignment::CENTER);
void RenderAlignedValue(duckdb::string_t str, idx_t width, TextAlignment alignment = TextAlignment::CENTER);
void PrintDashes(idx_t N);
void OutputQuotedIdentifier(const string &str);
void OutputQuotedString(const string &str);
public:
ShellState &state;
};
class ShellRenderer {
public:
explicit ShellRenderer(ShellState &state);
virtual ~ShellRenderer() = default;
ShellState &state;
bool show_header;
string col_sep;
string row_sep;
public:
virtual SuccessState RenderQueryResult(PrintStream &out, ShellState &state, RenderingQueryResult &result);
virtual void RemoveRenderLimits() {
}
virtual void Analyze(RenderingQueryResult &result);
virtual void RenderHeader(PrintStream &out, ResultMetadata &result);
virtual void RenderRow(PrintStream &out, ResultMetadata &result, RowData &row);
virtual void RenderFooter(PrintStream &out, ResultMetadata &result);
virtual const char *NullValue();
virtual bool RequireMaterializedResult() const = 0;
virtual bool ShouldUsePager(RenderingQueryResult &result, PagerMode global_mode) = 0;
virtual unique_ptr<duckdb::DataChunk> ConvertChunk(duckdb::DataChunk &chunk);
virtual bool HasConvertValue() {
return false;
}
virtual bool ShouldConvertValue(const char *value, idx_t str_len) {
return false;
}
virtual string ConvertValue(const char *value, idx_t str_len);
};
class ColumnRenderer : public ShellRenderer {
public:
explicit ColumnRenderer(ShellState &state);
void Analyze(RenderingQueryResult &result) override;
void RenderRow(PrintStream &out, ResultMetadata &result, RowData &row) override;
virtual const char *GetColumnSeparator() = 0;
virtual const char *GetRowSeparator() = 0;
virtual const char *GetRowStart() {
return nullptr;
}
bool RequireMaterializedResult() const override {
return true;
}
bool ShouldUsePager(RenderingQueryResult &result, PagerMode global_mode) override;
protected:
vector<idx_t> column_width;
vector<bool> right_align;
};
class RowRenderer : public ShellRenderer {
public:
explicit RowRenderer(ShellState &state);
public:
void RenderHeader(PrintStream &out, ResultMetadata &result) override;
bool RequireMaterializedResult() const override {
return false;
}
bool ShouldUsePager(RenderingQueryResult &result, PagerMode global_mode) override;
};
class ShellLogStorage : public duckdb::LogStorage {
public:
explicit ShellLogStorage(ShellState &state) : shell_highlight(state) {};
~ShellLogStorage() override = default;
const string GetStorageName() override {
return "ShellLogStorage";
}
protected:
void WriteLogEntry(duckdb::timestamp_t timestamp, duckdb::LogLevel level, const string &log_type,
const string &log_message, const duckdb::RegisteredLoggingContext &context) override;
void WriteLogEntries(duckdb::DataChunk &chunk, const duckdb::RegisteredLoggingContext &context) override {};
void FlushAll() override {};
void Flush(duckdb::LoggingTargetTable table) override {};
bool IsEnabled(duckdb::LoggingTargetTable table) override {
return true;
};
private:
ShellHighlight shell_highlight;
// Logs that have already been printed to avoid spamming the shell
duckdb::unordered_set<uint64_t> printed_logs;
// lock to ensure thread safety of the printed_logs set
mutable duckdb::mutex lock;
};
} // namespace duckdb_shell
|
