Should I use Factory Method design pattern for this problem?

Question

I'm working on an application which needs to open a database file. There are 2 "versions" of this database: one of them is more general data storage, and the other contains "less" information. That being said, database table structures are different, so I need to issue different queries to get "same" information from each of them.

My first thought is to create a query factory abstract interface, which will only have pure virtual methods returning the queries:

class IQueryFactory
{
public:
    virtual QString getNames() const = 0;
    virtual QString getSurnames() const = 0;
    // ...
};

and have this interface implemented for both "versions" of database:

class GeneralQueryFactory : public IQueryFactory
{
public:
    QString getNames() const override
    {
        return "SELECT DISTINCT Name FROM People;";
    }

    QString getSurnames() const override
    {
        return "SELECT DISTINCT Surname FROM People;";
    }

    // ...
}

class SpecificQueryFactory : public IQueryFactory
{
public:
    QString getNames() const override
    {
        return "SELECT DISTINCT FirstName FROM Employees;";
    }

    QString getSurnames() const override
    {
        return "SELECT DISTINCT LastName FROM Employees;";
    }

    // ...
}

I'm creating an instance of GeneralQueryFactory and SpecificQueryFactory at program startup, then when a database is to be loaded, I check if some table in database, and based on that store the corresponding query factory pointer with the database name in map:

GeneralQueryFactory generalFactory;
SpecificQueryFactory specificFactory;

// ...

if (...)
    dbInfo.add(dbPath, &app.generalFactory);
else
    dbInfo.add(dbPath, &app.specificFactory);

Later I use the query factory as follows (in another function):

auto queryFct = dbInfo.getQueryFactory(dbPath);
QSqlQuery sqlQuery(queryFct->getNames());
sqlQuery.exec();
// ...

I wanna know if this is done correctly. Is the usage of this design pattern correct for this problem? What can I improve? Thanks.

Answer 1

1. Your "Factory" is not a factory (ar least not in the way the GoF book defines it). But I think this is just a misnomer, what you have shown us here is the Strategy pattern. So consider to rename these classes to match the correct GoF terms.

   A factory method is one which makes the decision which strategy object to use, i.e.

    IQueryStrategy &PickQueryStrategy()
    {
        if (...)
          return &app.generalFactory;
       else
          return &app.specificFactory;
    }
   

2. If providing different sets of static strings is really the only thing which is required here, the strategy pattern is probably overdesigned. Two string lists which are kept in a dictionary, where the database type is some enum used as the key value for this dictionary requires less boilerplate code and would be probably simpler. The dbInfo object then just gets one of those lists assigned, and pick the right query by using another enum as an index.

   The code which uses this list would then look like this:

   auto queryList = dbInfo.getQueryList(dbPath);
   QSqlQuery sqlQuery(queryList[QueryIndex::FirstName]);
   

   However, as we don't know your "real" code, which may be more complex, using the strategy pattern may be perfectly justified, you have to decide this for yourself if there will be some different behaviour for each of the databases required.