Big tidy-up and add tools for building services

21 files changed, 235 insertions, 114 deletions

diff --git a/icetray/Jamfile.jam b/icetray/Jamfile.jam
index 36b6c61..9058895 100644
--- a/icetray/Jamfile.jam
+++ b/icetray/Jamfile.jam
@@ -16,6 +16,7 @@ build-project unittests ;
 
 lib icetray :
 	abstractDatabaseClient.cpp
+	abstractCachingDatabaseClient.cpp
 	defaultPool.cpp
 	icetrayService.cpp
 	:
@@ -58,6 +59,7 @@ lib dryice :
 	<include>.
 	;
 
-package.install install : <install-source-root>. : : icetray : abstractDatabaseClient.h icetrayService.h ;
-package.install installdryice : <install-source-root>. : : dryice : dryice.h ;
+package.install install-main : <install-source-root>. : : icetray : abstractDatabaseClient.h icetrayService.h ;
+package.install-data install-tools : boost-build/tools : icetray.jam [ glob embed.*.m4 ] ;
+package.install install-dryice : <install-source-root>. : : dryice : dryice.h ;
 
diff --git a/icetray/abstractCachingDatabaseClient.cpp b/icetray/abstractCachingDatabaseClient.cpp
new file mode 100644
index 0000000..2c97ac6
--- /dev/null
+++ b/icetray/abstractCachingDatabaseClient.cpp
@@ -0,0 +1,18 @@
+#include "abstractCachingDatabaseClient.h"
+#include <cache.impl.h>
+
+template DLL_PUBLIC void AdHoc::Cache<IceTray::AbstractCachingDatabaseClient::CacheItem, IceTray::AbstractCachingDatabaseClient::CacheKey>::add(const IceTray::AbstractCachingDatabaseClient::CacheKey &, const IceTray::AbstractCachingDatabaseClient::CacheItem &, time_t);
+template DLL_PUBLIC const IceTray::AbstractCachingDatabaseClient::CacheItem * AdHoc::Cache<IceTray::AbstractCachingDatabaseClient::CacheItem, IceTray::AbstractCachingDatabaseClient::CacheKey>::get(const IceTray::AbstractCachingDatabaseClient::CacheKey &) const;
+
+namespace IceTray {
+	AbstractCachingDatabaseClient::AbstractCachingDatabaseClient(DatabasePoolPtr d) :
+		AbstractDatabaseClient(d)
+	{
+	}
+
+	void
+	AbstractCachingDatabaseClient::keyPushParams(CacheKey &)
+	{
+	}
+}
+
diff --git a/icetray/abstractCachingDatabaseClient.h b/icetray/abstractCachingDatabaseClient.h
new file mode 100644
index 0000000..bb1d070
--- /dev/null
+++ b/icetray/abstractCachingDatabaseClient.h
@@ -0,0 +1,54 @@
+#ifndef ICETRAY_ABSTRACTCACHINGDATABASECLIENT_H
+#define ICETRAY_ABSTRACTCACHINGDATABASECLIENT_H
+
+#include "abstractDatabaseClient.h"
+#include <cache.h>
+#include <boost/any.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace IceTray {
+	class DLL_PUBLIC AbstractCachingDatabaseClient : public AbstractDatabaseClient {
+		private:
+			typedef std::vector<std::size_t> CacheKey;
+			typedef boost::shared_ptr<boost::any> CacheItem;
+
+		public:
+			AbstractCachingDatabaseClient(boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> d);
+
+			template<typename Domain, typename Sql, typename ... Params>
+			inline
+			Domain
+			fetchCache(time_t cacheTime, const Params & ... params)
+			{
+				CacheKey key;
+				key.reserve(sizeof...(Params) + 2);
+				key.push_back(Sql::hash);
+				key.push_back(typeid(Domain).hash_code());
+				keyPushParams(key, params...);
+				if (auto cached = cache.get(key)) {
+					auto d = boost::any_cast<Domain>(cached->get());
+					if (d) {
+						return *d;
+					}
+				}
+				auto d(fetch<Domain, Sql, Params...>(params...));
+				cache.add(key, CacheItem(new boost::any(d)), time(NULL) + cacheTime);
+				return d;
+			}
+
+		private:
+			template<typename Param, typename ... Params>
+			static void inline keyPushParams(CacheKey & k, const Param & p, const Params & ... params)
+			{
+				k.push_back(std::hash<Param>()(p));
+				keyPushParams(k, params...);
+			}
+
+			static void keyPushParams(CacheKey &);
+
+			AdHoc::Cache<CacheItem, CacheKey> cache;
+	};
+}
+
+#endif
+
diff --git a/icetray/abstractDatabaseClient.cpp b/icetray/abstractDatabaseClient.cpp
index 0d3489c..e5e3026 100644
--- a/icetray/abstractDatabaseClient.cpp
+++ b/icetray/abstractDatabaseClient.cpp
@@ -1,37 +1,28 @@
 #include "abstractDatabaseClient.h"
-#include <cache.impl.h>
-
-template DLL_PUBLIC void AdHoc::Cache<IceTray::AbstractDatabaseClient::CacheItem, IceTray::AbstractDatabaseClient::CacheKey>::add(const IceTray::AbstractDatabaseClient::CacheKey &, const IceTray::AbstractDatabaseClient::CacheItem &, time_t);
-template DLL_PUBLIC const IceTray::AbstractDatabaseClient::CacheItem * AdHoc::Cache<IceTray::AbstractDatabaseClient::CacheItem, IceTray::AbstractDatabaseClient::CacheKey>::get(const IceTray::AbstractDatabaseClient::CacheKey &) const;
 
 namespace IceTray {
-AbstractDatabaseClient::AbstractDatabaseClient(boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> d) :
-	db(d)
-{
-}
+	AbstractDatabaseClient::AbstractDatabaseClient(DatabasePoolPtr d) :
+		db(d)
+	{
+	}
 
-template<>
-void
-AbstractDatabaseClient::bind1(int o, DB::Command * cmd, const std::string & p)
-{
-	cmd->bindParamS(o, p);
-}
+	template<>
+	void
+	AbstractDatabaseClient::bind1(int o, DB::Command * cmd, const std::string & p)
+	{
+		cmd->bindParamS(o, p);
+	}
 
-template<>
-void
-AbstractDatabaseClient::bind1(int o, DB::Command * cmd, const int & p)
-{
-	cmd->bindParamI(o, p);
-}
+	template<>
+	void
+	AbstractDatabaseClient::bind1(int o, DB::Command * cmd, const int & p)
+	{
+		cmd->bindParamI(o, p);
+	}
 
-void
-AbstractDatabaseClient::bind(int, DB::Command *)
-{
-}
-
-void
-AbstractDatabaseClient::keyPushParams(CacheKey &)
-{
-}
+	void
+	AbstractDatabaseClient::bind(int, DB::Command *)
+	{
+	}
 }
 
diff --git a/icetray/abstractDatabaseClient.h b/icetray/abstractDatabaseClient.h
index 817d1ed..aac9151 100644
--- a/icetray/abstractDatabaseClient.h
+++ b/icetray/abstractDatabaseClient.h
@@ -1,66 +1,42 @@
-#ifndef ABSTRACTDATABASECLIENT_H
-#define ABSTRACTDATABASECLIENT_H
+#ifndef ICETRAY_ABSTRACTDATABASECLIENT_H
+#define ICETRAY_ABSTRACTDATABASECLIENT_H
 
-#include <connectionPool.h>
+#include "database.h"
 #include <db/sqlSelectDeserializer.h>
 #include <slicer/slicer.h>
-#include <cache.h>
-#include <boost/any.hpp>
-#include <boost/shared_ptr.hpp>
 #include <visibility.h>
 
 namespace IceTray {
-class DLL_PUBLIC AbstractDatabaseClient {
-	public:
-		AbstractDatabaseClient(boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> d);
-		typedef std::vector<std::size_t> CacheKey;
-		typedef boost::shared_ptr<boost::any> CacheItem;
-
-		template<typename Domain, typename Sql, typename ... Params>
-		Domain inline fetch(const Params & ... params)
-		{
-			CacheKey key;
-			key.reserve(sizeof...(Params) + 2);
-			key.push_back(Sql::hash);
-			key.push_back(typeid(Domain).hash_code());
-			keyPushParams(key, params...);
-			if (auto cached = cache.get(key)) {
-				return boost::any_cast<Domain>(**cached);
+	class DLL_PUBLIC AbstractDatabaseClient {
+		public:
+			AbstractDatabaseClient(DatabasePoolPtr d);
+
+			template<typename Domain, typename Sql, typename ... Params>
+			inline
+			Domain
+			fetch(const Params & ... params)
+			{
+				auto c = db->get();
+				auto s = DB::SelectCommandPtr(c->newSelectCommand(Sql::sql));
+				bind(0, s.get(), params...);
+				return Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Domain>(*s);
 			}
-			auto c = db->get();
-			auto s = DB::SelectCommandPtr(c->newSelectCommand(Sql::sql));
-			bind(0, s.get(), params...);
-			Domain d = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, Domain>(*s);
-			s.reset();
-			c.release();
-			cache.add(key, CacheItem(new boost::any(d)), time(NULL) + 40);
-			return d;
-		}
-
-		template<typename Param, typename ... Params>
-		static void inline bind(int offset, DB::Command * cmd, const Param & p, const Params & ... params)
-		{
-			bind1(offset, cmd, p);
-			bind(offset + 1, cmd, params...);
-		}
 
-		static void bind(int offset, DB::Command * cmd);
-
-		template<typename Param>
-		static void bind1(int offset, DB::Command * cmd, const Param & p);
+		private:
+			template<typename Param, typename ... Params>
+			static void inline bind(int offset, DB::Command * cmd, const Param & p, const Params & ... params)
+			{
+				bind1(offset, cmd, p);
+				bind(offset + 1, cmd, params...);
+			}
 
-		template<typename Param, typename ... Params>
-		static void inline keyPushParams(CacheKey & k, const Param & p, const Params & ... params)
-		{
-			k.push_back(std::hash<Param>()(p));
-			keyPushParams(k, params...);
-		}
+			static void bind(int offset, DB::Command * cmd);
 
-		static void keyPushParams(CacheKey &);
+			template<typename Param>
+			static void bind1(int offset, DB::Command * cmd, const Param & p);
 
-		boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> db;
-		AdHoc::Cache<CacheItem, CacheKey> cache;
-};
+			DatabasePoolPtr db;
+	};
 }
 
 #endif
diff --git a/icetray/database.h b/icetray/database.h
new file mode 100644
index 0000000..23ad7fe
--- /dev/null
+++ b/icetray/database.h
@@ -0,0 +1,13 @@
+#ifndef ICETRAY_DATABASE_H
+#define ICETRAY_DATABASE_H
+
+#include <connectionPool.h>
+#include <boost/shared_ptr.hpp>
+
+namespace IceTray {
+	typedef AdHoc::ResourcePool<DB::Connection> DatabasePool;
+	typedef boost::shared_ptr<DatabasePool> DatabasePoolPtr;
+}
+
+#endif
+
diff --git a/icetray/embed.sql.cpp.m4 b/icetray/embed.sql.cpp.m4
new file mode 100644
index 0000000..7043f78
--- /dev/null
+++ b/icetray/embed.sql.cpp.m4
@@ -0,0 +1,7 @@
+changecom(`@@')
+#include "NAME.sql.h"
+
+const std::string NAMESPACE::NAME::sql({
+patsubst(esyscmd(`xxd -p -c 12 ' SQL), `\(..\)', `0x\1, ')0x00});
+const std::size_t NAMESPACE::NAME::hash(std::hash<std::string>()(sql));
+
diff --git a/icetray/embed.sql.h.m4 b/icetray/embed.sql.h.m4
new file mode 100644
index 0000000..fbabf62
--- /dev/null
+++ b/icetray/embed.sql.h.m4
@@ -0,0 +1,15 @@
+define(`foreach',`ifelse(eval($#>2),1,
+	`pushdef(`$1',`$3')$2`'popdef(`$1')
+  `'ifelse(eval($#>3),1,`$0(`$1',`$2',shift(shift(shift($@))))')')')
+define(NAMESPACEC,`patsubst(NAMESPACE,`::', `,')')
+#include <functional>
+#include <string>
+
+foreach(`ns', `namespace ns {	', NAMESPACEC)
+	class NAME {
+		public:
+			static const std::string sql;
+			static const std::size_t hash;
+	};
+foreach(`ns', `}', NAMESPACEC)
+
diff --git a/icetray/icetray.jam b/icetray/icetray.jam
new file mode 100644
index 0000000..f999e2d
--- /dev/null
+++ b/icetray/icetray.jam
@@ -0,0 +1,34 @@
+import generators ;
+import feature ;
+import type ;
+import path ;
+import property ;
+import project ;
+import regex ;
+
+project.initialize $(__name__) ;
+project icetray ;
+
+feature.feature icetray.sql.namespace : : free ;
+type.register SQL : sql ;
+generators.register-standard icetray.c++.sql : SQL : CPP(%.sql) H(%.sql) ;
+
+path-constant icetray-root : . ;
+
+rule icetray.c++.sql ( cpp h : sql : properties * )
+{
+	local namespace = [ property.select icetray.sql.namespace : $(properties) ] ;
+	local relpath = [ path.relative-to . $(sql:D) ] ;
+	namespace = [ regex.replace $(namespace:G=)/$(relpath) "\\/\\." "" ] ;
+	namespace = [ regex.replace $(namespace) "\\/" "::" ] ;
+	NAMESPACE on $(<) = -DNAMESPACE=\"$(namespace)\" ;
+}
+
+actions icetray.c++.sql
+{
+	m4 $(NAMESPACE) -DNAME="$(2:B)" -DSQL="$(2[1])" "$(icetray-root)/embed.sql.cpp.m4" > "$(1[1])"
+	m4 $(NAMESPACE) -DNAME="$(2:B)" "$(icetray-root)/embed.sql.h.m4" > "$(1[2])"
+}
+
+IMPORT $(__name__) : icetray.c++.sql : : icetray.c++.sql ;
+
diff --git a/icetray/icetrayService.cpp b/icetray/icetrayService.cpp
index 335c08b..aff6a8a 100644
--- a/icetray/icetrayService.cpp
+++ b/icetray/icetrayService.cpp
@@ -17,10 +17,10 @@ namespace IceTray {
 		adp->destroy();
 	}
 
-	boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> Service::getConnectionPool(const Ice::CommunicatorPtr & ic, const std::string & type, const std::string & name)
+	DatabasePoolPtr Service::getConnectionPool(const Ice::CommunicatorPtr & ic, const std::string & type, const std::string & name)
 	{
 		auto p = ic->getProperties();
-		return boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>>(PoolProvider::createNew(
+		return DatabasePoolPtr(PoolProvider::createNew(
 					p->getPropertyWithDefault("DryIce.PoolProvider", "DefaultPool"),
 					name, type, p));
 	}
@@ -36,5 +36,5 @@ extern "C" {
 }
 
 INSTANTIATEVOIDFACTORY(IceTray::Service);
-INSTANTIATEFACTORY(IceTray::PoolType, const std::string &, const std::string &, Ice::PropertiesPtr);
+INSTANTIATEFACTORY(IceTray::DatabasePool, const std::string &, const std::string &, Ice::PropertiesPtr);
 
diff --git a/icetray/icetrayService.h b/icetray/icetrayService.h
index 10a1700..8f35519 100644
--- a/icetray/icetrayService.h
+++ b/icetray/icetrayService.h
@@ -4,29 +4,24 @@
 #include <IceBox/IceBox.h>
 #include <factory.h>
 #include <visibility.h>
-#include <connectionPool.h>
+#include "database.h"
 
 namespace IceTray {
-	typedef AdHoc::ResourcePool<DB::Connection> PoolType;
-	typedef boost::shared_ptr<PoolType> PoolTypePtr;
-
 	class DLL_PUBLIC Service : public IceBox::Service, public AdHoc::AbstractPluginImplementation {
 		public:
-			typedef boost::shared_ptr<DB::ConnectionPool> DBCPoolPtr;
-
 			virtual void addObjects(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq &, const Ice::ObjectAdapterPtr &) = 0;
 
 			void start(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq & args) override;
 
 			void stop() override;
 
-			PoolTypePtr getConnectionPool(const Ice::CommunicatorPtr & ic, const std::string & type, const std::string & prefix);
+			DatabasePoolPtr getConnectionPool(const Ice::CommunicatorPtr & ic, const std::string & type, const std::string & prefix);
 
 			Ice::ObjectAdapterPtr adp;
 	};
 
 	typedef AdHoc::Factory<Service> ServiceFactory;
-	typedef AdHoc::Factory<PoolType, const std::string &, const std::string &, Ice::PropertiesPtr> PoolProvider;
+	typedef AdHoc::Factory<DatabasePool, const std::string &, const std::string &, Ice::PropertiesPtr> PoolProvider;
 }
 
 #endif
diff --git a/icetray/mockPool.cpp b/icetray/mockPool.cpp
index 3035949..43e7c0c 100644
--- a/icetray/mockPool.cpp
+++ b/icetray/mockPool.cpp
@@ -4,7 +4,7 @@
 
 namespace IceTray {
 	MockPool::MockPool(const std::string & name, const std::string &, Ice::PropertiesPtr p) :
-		AdHoc::ResourcePool<DB::Connection>(
+		DatabasePool(
 					p->getPropertyAsIntWithDefault(name + ".Database.PoolMax", 10),
 					p->getPropertyAsIntWithDefault(name + ".Database.PoolKeep", 2)),
 		name(name)
diff --git a/icetray/mockPool.h b/icetray/mockPool.h
index 6a2df85..8936cb2 100644
--- a/icetray/mockPool.h
+++ b/icetray/mockPool.h
@@ -1,12 +1,12 @@
 #ifndef ICETRAY_MOCKPOOL_H
 #define ICETRAY_MOCKPOOL_H
 
-#include <connectionPool.h>
+#include "database.h"
 #include <mockDatabase.h>
 #include <Ice/Properties.h>
 
 namespace IceTray {
-	class MockPool : public AdHoc::ResourcePool<DB::Connection> {
+	class MockPool : public DatabasePool {
 		public:
 			MockPool(const std::string & name, const std::string &, Ice::PropertiesPtr p);
 
diff --git a/icetray/unittests/Jamfile.jam b/icetray/unittests/Jamfile.jam
index b1a9e40..459f103 100644
--- a/icetray/unittests/Jamfile.jam
+++ b/icetray/unittests/Jamfile.jam
@@ -1,4 +1,5 @@
 import testing ;
+import ../icetray ;
 
 lib boost_utf : : <name>boost_unit_test_framework ;
 lib boost_filesystem ;
@@ -19,13 +20,18 @@ alias testCommon : : : :
 	<library>..//boost_system
 	<define>BOOST_TEST_DYN_LINK
 	;
+
 run
 	testIceTray.cpp
 	testIceTrayService.ice
 	testIceTrayServiceI.cpp
+	testIceTrayServiceTestSql.sql
+	subdir/some.sql
+	subdir/a/more.sql
 	:
 	testIceTrayService.sql
 	: :
+	<icetray.sql.namespace>TestIceTray::sql
 	<library>testCommon
 	<library>boost_filesystem
 	<library>dbpp-postgresql
diff --git a/icetray/unittests/subdir/a/more.sql b/icetray/unittests/subdir/a/more.sql
new file mode 100644
index 0000000..815fee3
--- /dev/null
+++ b/icetray/unittests/subdir/a/more.sql
@@ -0,0 +1 @@
+SELECT MIN(id) FROM testTable
diff --git a/icetray/unittests/subdir/some.sql b/icetray/unittests/subdir/some.sql
new file mode 100644
index 0000000..815fee3
--- /dev/null
+++ b/icetray/unittests/subdir/some.sql
@@ -0,0 +1 @@
+SELECT MIN(id) FROM testTable
diff --git a/icetray/unittests/testIceTray.cpp b/icetray/unittests/testIceTray.cpp
index 39514f9..401a68c 100644
--- a/icetray/unittests/testIceTray.cpp
+++ b/icetray/unittests/testIceTray.cpp
@@ -40,7 +40,8 @@ BOOST_AUTO_TEST_CASE( services )
 {
 	BOOST_REQUIRE(p);
 	p->ice_ping();
-	p->method();
+	p->method1();
+	p->method2(1, "test");
 }
 
 BOOST_AUTO_TEST_SUITE_END();
diff --git a/icetray/unittests/testIceTrayService.ice b/icetray/unittests/testIceTrayService.ice
index 9c17127..e0a3dad 100644
--- a/icetray/unittests/testIceTrayService.ice
+++ b/icetray/unittests/testIceTrayService.ice
@@ -1,6 +1,7 @@
 module TestIceTray {
 	interface TestIceTrayService {
-		void method();
+		void method1();
+		void method2(int id, string name);
 	};
 };
 
diff --git a/icetray/unittests/testIceTrayServiceI.cpp b/icetray/unittests/testIceTrayServiceI.cpp
index 501e1b1..dde1d92 100644
--- a/icetray/unittests/testIceTrayServiceI.cpp
+++ b/icetray/unittests/testIceTrayServiceI.cpp
@@ -3,24 +3,25 @@
 #include <Ice/ObjectAdapter.h>
 #include <Ice/Communicator.h>
 #include <boost/assert.hpp>
+#include <testIceTrayServiceTestSql.sql.h>
+#include <subdir/some.sql.h>
+#include <subdir/a/more.sql.h>
 
 namespace TestIceTray {
-	struct TestSql {
-		static const std::string sql;
-		static const std::size_t hash;
-	};
-	const std::string TestSql::sql("SELECT COUNT(*) FROM testTable WHERE id = ? AND name = ?");
-	const std::size_t TestSql::hash(std::hash<std::string>()(sql));
-	TestIceTrayServiceI::TestIceTrayServiceI(boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> d) :
-		IceTray::AbstractDatabaseClient(d)
+	TestIceTrayServiceI::TestIceTrayServiceI(IceTray::DatabasePoolPtr d) :
+		IceTray::AbstractCachingDatabaseClient(d)
 	{
 	}
 
-	void TestIceTrayServiceI::method(const Ice::Current &)
+	void TestIceTrayServiceI::method1(const Ice::Current &)
 	{
-		Ice::Int id = 4;
-		std::string name = "test";
-		BOOST_VERIFY((fetch<int, TestSql>(id, name)) == (fetch<int, TestSql>(id, name)));
+		fetch<int, sql::subdir::some>();
+		fetch<int, sql::subdir::a::more>();
+	}
+
+	void TestIceTrayServiceI::method2(Ice::Int id, const std::string & name, const Ice::Current &)
+	{
+		BOOST_VERIFY((fetchCache<int, sql::testIceTrayServiceTestSql>(10, id, name)) == (fetchCache<int, sql::testIceTrayServiceTestSql>(10, id, name)));
 	}
 
 	void TestService::addObjects(const std::string &, const Ice::CommunicatorPtr & ic, const Ice::StringSeq &, const Ice::ObjectAdapterPtr & adp)
diff --git a/icetray/unittests/testIceTrayServiceI.h b/icetray/unittests/testIceTrayServiceI.h
index 6bb5503..193a92b 100644
--- a/icetray/unittests/testIceTrayServiceI.h
+++ b/icetray/unittests/testIceTrayServiceI.h
@@ -3,14 +3,15 @@
 
 #include <testIceTrayService.h>
 #include <icetrayService.h>
-#include <abstractDatabaseClient.h>
+#include <abstractCachingDatabaseClient.h>
 
 namespace TestIceTray {
-	class TestIceTrayServiceI : IceTray::AbstractDatabaseClient, public TestIceTrayService {
+	class TestIceTrayServiceI : IceTray::AbstractCachingDatabaseClient, public TestIceTrayService {
 		public:
 			TestIceTrayServiceI(boost::shared_ptr<AdHoc::ResourcePool<DB::Connection>> db);
 
-			void method(const Ice::Current &) override;
+			void method1(const Ice::Current &) override;
+			void method2(Ice::Int id, const std::string & name, const Ice::Current &) override;
 	};
 
 	class TestService : public IceTray::Service {
diff --git a/icetray/unittests/testIceTrayServiceTestSql.sql b/icetray/unittests/testIceTrayServiceTestSql.sql
new file mode 100644
index 0000000..162c801
--- /dev/null
+++ b/icetray/unittests/testIceTrayServiceTestSql.sql
@@ -0,0 +1,4 @@
+SELECT COUNT(*)
+FROM testTable
+WHERE id = ?
+AND name = ?