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
|
/*
* Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/NonnullOwnPtr.h>
#include <AK/NonnullOwnPtrVector.h>
#include <AK/NonnullRefPtr.h>
#include <AK/Result.h>
#include <AK/String.h>
#include <AK/Vector.h>
#include <LibCore/Object.h>
#include <LibSQL/Forward.h>
#include <LibSQL/Key.h>
#include <LibSQL/Type.h>
namespace SQL {
/**
* This file declares objects describing tables, indexes, and columns.
* It remains to be seen if this will survive in it's current form.
*/
class Relation : public Core::Object {
C_OBJECT_ABSTRACT(Relation);
public:
u32 hash() const { return key().hash(); }
u32 pointer() const { return m_pointer; }
void set_pointer(u32 pointer) { m_pointer = pointer; }
~Relation() override = default;
virtual Key key() const = 0;
Relation const* parent_relation() const { return dynamic_cast<Relation const*>(parent()); }
protected:
Relation(String name, u32 pointer, Relation* parent = nullptr)
: Core::Object(parent)
, m_pointer(pointer)
{
set_name(move(name));
}
explicit Relation(String name, Relation* parent = nullptr)
: Core::Object(parent)
, m_pointer(0)
{
set_name(move(name));
}
private:
u32 m_pointer { 0 };
};
class SchemaDef : public Relation {
C_OBJECT(SchemaDef);
public:
Key key() const override;
static NonnullRefPtr<IndexDef> index_def();
static Key make_key();
private:
explicit SchemaDef(String);
explicit SchemaDef(Key const&);
};
class ColumnDef : public Relation {
C_OBJECT(ColumnDef);
public:
Key key() const override;
SQLType type() const { return m_type; }
size_t column_number() const { return m_index; }
static NonnullRefPtr<IndexDef> index_def();
static Key make_key(TableDef const&);
protected:
ColumnDef(Relation*, size_t, String, SQLType);
private:
size_t m_index;
SQLType m_type { SQLType::Text };
};
class KeyPartDef : public ColumnDef {
C_OBJECT(KeyPartDef);
public:
KeyPartDef(IndexDef*, String, SQLType, Order = Order::Ascending);
Order sort_order() const { return m_sort_order; }
private:
Order m_sort_order { Order::Ascending };
};
class IndexDef : public Relation {
C_OBJECT(IndexDef);
public:
~IndexDef() override = default;
NonnullRefPtrVector<KeyPartDef> key_definition() const { return m_key_definition; }
bool unique() const { return m_unique; }
[[nodiscard]] size_t size() const { return m_key_definition.size(); }
void append_column(String, SQLType, Order = Order::Ascending);
Key key() const override;
[[nodiscard]] TupleDescriptor to_tuple_descriptor() const;
static NonnullRefPtr<IndexDef> index_def();
static Key make_key(TableDef const& table_def);
private:
IndexDef(TableDef*, String, bool unique = true, u32 pointer = 0);
explicit IndexDef(String, bool unique = true, u32 pointer = 0);
NonnullRefPtrVector<KeyPartDef> m_key_definition;
bool m_unique { false };
friend TableDef;
};
class TableDef : public Relation {
C_OBJECT(TableDef);
public:
Key key() const override;
void append_column(String, SQLType);
void append_column(Key const&);
size_t num_columns() { return m_columns.size(); }
size_t num_indexes() { return m_indexes.size(); }
NonnullRefPtrVector<ColumnDef> columns() const { return m_columns; }
NonnullRefPtrVector<IndexDef> indexes() const { return m_indexes; }
[[nodiscard]] TupleDescriptor to_tuple_descriptor() const;
static NonnullRefPtr<IndexDef> index_def();
static Key make_key(SchemaDef const& schema_def);
static Key make_key(Key const& schema_key);
private:
explicit TableDef(SchemaDef*, String);
NonnullRefPtrVector<ColumnDef> m_columns;
NonnullRefPtrVector<IndexDef> m_indexes;
};
}
|
