repos/DecentralizedMedia/Library.cpp

// Library
//
// Douglas Thrift
//
// $Id$

#include <menes/c++/standard.hh>

#include <menes/dbi/resultset.hpp>

#include "Library.hpp"

Library::Library(const _R<Connector>& connector) : connector(connector)
{
        _R<dbi::Connection> connection(connector->Connect());

        connection->Execute(_B("UPDATE files SET live = FALSE"));

        connector->Release(connection);
}

_L<MediaFolder> Library::GetFolders(unsigned page) const
{
        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::ResultSet> roots(connection->Parse(_B("SELECT DISTINCT root FROM files WHERE live = TRUE ORDER By root LIMIT 50 OFFSET ?"))->Execute(page * 50));
        _L<MediaFolder> folders;

        while (roots->MoveNext())
                folders.InsertLast(GetFolder(roots->GetString(_B("root"))));

        connector->Release(connection);

        return folders;
}

unsigned Library::GetFoldersPages() const
{
        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::ResultSet> count(connection->Execute(_B("SELECT count(DISTINCT root) FROM files WHERE live = TRUE")));
        unsigned pages(0);

        if (count->MoveNext())
                pages = (count->Get<unsigned>(_B("count")) + 49) / 50;

        connector->Release(connection);

        return pages;
}

_L<MediaFile> Library::GetFiles(const _L<By>& bys, const _L<cse::String>& items, unsigned page) const
{
        if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() != items.GetSize())
                return _L<MediaFile>();

        _S<ios::String> statement_;

        statement_ << _B("SELECT path FROM files WHERE live = TRUE ");

        _foreach (const _L<By>, by, bys)
                statement_ << _B("AND ") << *by << _B(" = ? ");

        statement_ << _B("ORDER BY path LIMIT 50 OFFSET ?");

        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::Statement> statement(connection->Parse(statement_));

        _foreach (const _L<cse::String>, item, items)
                statement->Set(_index, *item);

        statement->Set(items.GetSize(), page * 50);

        _R<dbi::ResultSet> paths(statement->Execute());
        _L<MediaFile> files;

        while (paths->MoveNext())
                files.InsertLast(GetFile(paths->GetString(_B("path"))));

        connector->Release(connection);

        return files;
}

unsigned Library::GetFilesPages(const _L<By>& bys, const _L<cse::String>& items) const
{
        if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() != items.GetSize())
                return 0;

        _S<ios::String> statement_;

        statement_ << _B("SELECT count(path) FROM files WHERE live = TRUE ");

        _foreach (const _L<By>, by, bys)
                statement_ << _B("AND ") << *by << _B(" = ?");

        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::Statement> statement(connection->Parse(statement_));

        _foreach (const _L<cse::String>, item, items)
                statement->Set(_index, *item);

        _R<dbi::ResultSet> count(statement->Execute());
        unsigned pages(0);

        if (count->MoveNext())
                pages = (count->Get<unsigned>(_B("count")) + 49) / 50;

        connector->Release(connection);

        return pages;
}

_L<cse::String> Library::GetItems(_L<By> bys, _L<cse::String> items, unsigned page) const
{
        if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() - 1 != items.GetSize())
                return _L<cse::String>();

        _S<ios::String> statement_;
        By by(bys.Last());

        statement_ << _B("SELECT DISTINCT ") << by << _B(" FROM files WHERE live = TRUE ");

        bys.RemoveLast();

        _foreach (const _L<By>, by_, bys)
                statement_ << _B("AND ") << *by_ << _B(" = ? ");

        statement_ << _B("ORDER BY ") << by << _B(" LIMIT 50 OFFSET ?");

        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::Statement> statement(connection->Parse(statement_));

        _foreach (const _L<cse::String>, item, items)
                statement->Set(_index, *item);

        statement->Set(items.GetSize(), page * 50);

        _R<dbi::ResultSet> items_(statement->Execute());
        
        items.Clear();

        while (items_->MoveNext())
                items.InsertLast(items_->GetString(lexical_cast<cse::String>(by)));

        connector->Release(connection);

        return items;
}

unsigned Library::GetItemsPages(_L<By> bys, const _L<cse::String>& items) const
{
        if (bys.IsEmpty() || ext::Contains(bys, By::LAST) || bys.GetSize() - 1 != items.GetSize())
                return 0;

        _S<ios::String> statement_;
        By by(bys.Last());

        statement_ << _B("SELECT count(DISTINCT ") << by << _B(") FROM files WHERE live = TRUE");

        bys.RemoveLast();

        _foreach (const _L<By>, by_, bys)
                statement_ << _B(" AND ") << *by_ << _B(" = ?");

        _R<dbi::Connection> connection(connector->Connect());
        _R<dbi::Statement> statement(connection->Parse(statement_));

        _foreach (const _L<cse::String>, item, items)
                statement->Set(_index, *item);

        _R<dbi::ResultSet> count(statement->Execute());
        unsigned pages(0);

        if (count->MoveNext())
                pages = (count->Get<unsigned>(_B("count")) + 49) / 50;

        connector->Release(connection);

        return pages;
}
Revision:	556
Committed:	2005-07-11T03:24:59-07:00 (19 years, 11 months ago) by douglas
File size:	4686 byte(s)
Log Message:	Pages almost working!
#	User	Rev	Content
1	douglas	542	// Library
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	553	#include <menes/c++/standard.hh>
8	douglas	542
9	douglas	549	#include <menes/dbi/resultset.hpp>
10	douglas	542
11			#include "Library.hpp"
12
13	douglas	555	Library::Library(const _R<Connector>& connector) : connector(connector)
14	douglas	542	{
15	douglas	555	_R<dbi::Connection> connection(connector->Connect());
16
17	douglas	542	connection->Execute(_B("UPDATE files SET live = FALSE"));
18	douglas	555
19			connector->Release(connection);
20	douglas	542	}
21
22	douglas	554	_L<MediaFolder> Library::GetFolders(unsigned page) const
23	douglas	542	{
24	douglas	555	_R<dbi::Connection> connection(connector->Connect());
25	douglas	554	_R<dbi::ResultSet> roots(connection->Parse(_B("SELECT DISTINCT root FROM files WHERE live = TRUE ORDER By root LIMIT 50 OFFSET ?"))->Execute(page * 50));
26	douglas	552	_L<MediaFolder> folders;
27	douglas	542
28	douglas	552	while (roots->MoveNext())
29			folders.InsertLast(GetFolder(roots->GetString(_B("root"))));
30	douglas	542
31	douglas	555	connector->Release(connection);
32
33	douglas	552	return folders;
34	douglas	542	}
35
36	douglas	556	unsigned Library::GetFoldersPages() const
37			{
38			_R<dbi::Connection> connection(connector->Connect());
39			_R<dbi::ResultSet> count(connection->Execute(_B("SELECT count(DISTINCT root) FROM files WHERE live = TRUE")));
40			unsigned pages(0);
41
42			if (count->MoveNext())
43			pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
44
45			connector->Release(connection);
46
47			return pages;
48			}
49
50	douglas	554	_L<MediaFile> Library::GetFiles(const _L<By>& bys, const _L<cse::String>& items, unsigned page) const
51	douglas	542	{
52	douglas	552	if (bys.IsEmpty() \|\| ext::Contains(bys, By::LAST) \|\| bys.GetSize() != items.GetSize())
53			return _L<MediaFile>();
54	douglas	542
55	douglas	552	_S<ios::String> statement_;
56	douglas	542
57	douglas	552	statement_ << _B("SELECT path FROM files WHERE live = TRUE ");
58	douglas	542
59	douglas	552	_foreach (const _L<By>, by, bys)
60	douglas	554	statement_ << _B("AND ") << *by << _B(" = ? ");
61	douglas	542
62	douglas	554	statement_ << _B("ORDER BY path LIMIT 50 OFFSET ?");
63	douglas	542
64	douglas	555	_R<dbi::Connection> connection(connector->Connect());
65	douglas	552	_R<dbi::Statement> statement(connection->Parse(statement_));
66	douglas	542
67	douglas	552	_foreach (const _L<cse::String>, item, items)
68			statement->Set(_index, *item);
69	douglas	542
70	douglas	554	statement->Set(items.GetSize(), page * 50);
71
72	douglas	552	_R<dbi::ResultSet> paths(statement->Execute());
73			_L<MediaFile> files;
74	douglas	542
75	douglas	552	while (paths->MoveNext())
76			files.InsertLast(GetFile(paths->GetString(_B("path"))));
77
78	douglas	555	connector->Release(connection);
79
80	douglas	552	return files;
81	douglas	542	}
82
83	douglas	556	unsigned Library::GetFilesPages(const _L<By>& bys, const _L<cse::String>& items) const
84			{
85			if (bys.IsEmpty() \|\| ext::Contains(bys, By::LAST) \|\| bys.GetSize() != items.GetSize())
86			return 0;
87
88			_S<ios::String> statement_;
89
90			statement_ << _B("SELECT count(path) FROM files WHERE live = TRUE ");
91
92			_foreach (const _L<By>, by, bys)
93			statement_ << _B("AND ") << *by << _B(" = ?");
94
95			_R<dbi::Connection> connection(connector->Connect());
96			_R<dbi::Statement> statement(connection->Parse(statement_));
97
98			_foreach (const _L<cse::String>, item, items)
99			statement->Set(_index, *item);
100
101			_R<dbi::ResultSet> count(statement->Execute());
102			unsigned pages(0);
103
104			if (count->MoveNext())
105			pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
106
107			connector->Release(connection);
108
109			return pages;
110			}
111
112	douglas	554	_L<cse::String> Library::GetItems(_L<By> bys, _L<cse::String> items, unsigned page) const
113	douglas	542	{
114	douglas	552	if (bys.IsEmpty() \|\| ext::Contains(bys, By::LAST) \|\| bys.GetSize() - 1 != items.GetSize())
115			return _L<cse::String>();
116	douglas	542
117	douglas	552	_S<ios::String> statement_;
118			By by(bys.Last());
119	douglas	554
120	douglas	552	statement_ << _B("SELECT DISTINCT ") << by << _B(" FROM files WHERE live = TRUE ");
121	douglas	542
122	douglas	552	bys.RemoveLast();
123
124			_foreach (const _L<By>, by_, bys)
125			statement_ << _B("AND ") << *by_ << _B(" = ? ");
126
127	douglas	554	statement_ << _B("ORDER BY ") << by << _B(" LIMIT 50 OFFSET ?");
128	douglas	552
129	douglas	555	_R<dbi::Connection> connection(connector->Connect());
130	douglas	552	_R<dbi::Statement> statement(connection->Parse(statement_));
131
132			_foreach (const _L<cse::String>, item, items)
133			statement->Set(_index, *item);
134
135	douglas	554	statement->Set(items.GetSize(), page * 50);
136
137	douglas	552	_R<dbi::ResultSet> items_(statement->Execute());
138
139			items.Clear();
140
141			while (items_->MoveNext())
142	douglas	554	items.InsertLast(items_->GetString(lexical_cast<cse::String>(by)));
143	douglas	552
144	douglas	555	connector->Release(connection);
145
146	douglas	552	return items;
147	douglas	542	}
148	douglas	556
149			unsigned Library::GetItemsPages(_L<By> bys, const _L<cse::String>& items) const
150			{
151			if (bys.IsEmpty() \|\| ext::Contains(bys, By::LAST) \|\| bys.GetSize() - 1 != items.GetSize())
152			return 0;
153
154			_S<ios::String> statement_;
155			By by(bys.Last());
156
157			statement_ << _B("SELECT count(DISTINCT ") << by << _B(") FROM files WHERE live = TRUE");
158
159			bys.RemoveLast();
160
161			_foreach (const _L<By>, by_, bys)
162			statement_ << _B(" AND ") << *by_ << _B(" = ?");
163
164			_R<dbi::Connection> connection(connector->Connect());
165			_R<dbi::Statement> statement(connection->Parse(statement_));
166
167			_foreach (const _L<cse::String>, item, items)
168			statement->Set(_index, *item);
169
170			_R<dbi::ResultSet> count(statement->Execute());
171			unsigned pages(0);
172
173			if (count->MoveNext())
174			pages = (count->Get<unsigned>(_B("count")) + 49) / 50;
175
176			connector->Release(connection);
177
178			return pages;
179			}