src/DAL/SelectionMask.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "SelectionMask.h"
  22 #include "SavableManager.h"
  23 #include "SavableManagers.h"
  24 #include "TableImpl.h"
  25 #include "KeyDef.h"
  26 #include "FieldImpl.h"
  27 #include "FieldValue.h"
  28 #include "FieldValues.h"
  29 #include "KeyValue.h"
  30 #include "KeyImpl.h"
  31 #include "Keys.h"
  32 #include "Relation.h"
  33 #include "Assert.h"
  34 #include "Join.h"
  35
  36 SelectionMask::SelectionMask(TableImplPtr table) :
  37 m_nativeTable(table),
  38 m_values(ValuesPtr(new FieldValues(table))),
  39 m_result(SavableManagersPtr(new SavableManagers(table))),
  40 m_count(0)
  41 {
  42         Assert(table);
  43 }
  44
  45 SelectionMask::~SelectionMask()
  46 {
  47
  48 }
  49
  50 TableImplPtr SelectionMask::getTable() const
  51 {
  52         return m_nativeTable;
  53 }
  54
  55 void SelectionMask::addField(FieldValuePtr value)
  56 {
  57         Assert(value);
  58         Assert(isReachableTable(value->getTable()));
  59
  60         std::string fieldname = value->getTable()->getName();
  61         fieldname.append(".");
  62         fieldname.append(value->getField()->getName());
  63         m_restrictions.push_back(fieldname);
  64         m_values->addValue(value);
  65 }
  66
  67 void SelectionMask::addField(FieldImplPtr field, cstring value)
  68 {
  69         Assert(field);
  70
  71         FieldValuePtr fieldvalue(new FieldValue(field, value));
  72         addField(fieldvalue);
  73 }
  74
  75 void SelectionMask::addField(FieldImplPtr field, value_type value)
  76 {
  77         Assert(field);
  78
  79         FieldValuePtr fieldvalue(new FieldValue(field, value));
  80         addField(fieldvalue);
  81 }
  82
  83 void SelectionMask::addJoin(TableImplPtr joinTable, KeyImplPtr nativeKey, KeyImplPtr foreignKey)
  84 {
  85         Assert(joinTable);
  86         Assert(nativeKey);
  87         Assert(foreignKey);
  88
  89         addJoin(m_nativeTable, joinTable, nativeKey, foreignKey);
  90 }
  91
  92 void SelectionMask::addJoin(TableImplPtr nativeTable, TableImplPtr joinTable, KeyImplPtr nativeKey, KeyImplPtr foreignKey)
  93 {
  94         Assert(joinTable);
  95         Assert(nativeKey);
  96         Assert(foreignKey);
  97         Assert(foreignKey->getTable() == joinTable);
  98         Assert(nativeKey->getTable() == nativeTable);
  99
 100         Assert(isReachableTable(nativeTable));
 101
 102         JoinPtr join(new Join(nativeTable, joinTable, nativeKey, foreignKey));
 103         addJoin(join);
 104 }
 105
 106 void SelectionMask::addJoin(JoinPtr join)
 107 {
 108         Assert(join);
 109         Assert(isReachableTable(join->getNativeKey()->getTable()));
 110
 111         m_joins.push_back(join);
 112         m_foreignTables.push_back(join->getJoinTable());
 113         m_values->addJoinedTable(join->getJoinTable());
 114 }
 115
 116 void SelectionMask::bindSelectMulti(sqlite3* db, sqlite3_stmt* statement) const
 117 {
 118         Assert(db);
 119         Assert(statement);
 120
 121         int n = 1;
 122         for(ValueMap::const_iterator it = m_values->begin(); it != m_values->end(); it++)
 123         {
 124                 ValuePtr value = it->second;
 125                 int rc = 0;
 126
 127                 if(value->getField()->isText())
 128                 {
 129                         std::string stringvalue = value->getStringValue();
 130                         rc = sqlite3_bind_text(statement, n, stringvalue.c_str(), stringvalue.size(), SQLITE_TRANSIENT);
 131                 }
 132                 else
 133                 {
 134                         value_type intvalue = value->getIntegerValue();
 135                         rc = sqlite3_bind_int64(statement, n, intvalue);
 136                 }
 137
 138                 if(rc != SQLITE_OK)
 139                         throw SqliteError(db);
 140
 141                 n++;
 142         }
 143 }
 144
 145 void SelectionMask::parseRow(sqlite3_stmt* statement)
 146 {
 147         Assert(statement);
 148
 149         SavableManagerPtr manager = SavableManager::getnew(m_nativeTable);
 150
 151         bool locked = manager->lock();
 152         Assert(locked); // new, so should always be unlocked
 153
 154         /// Begin locked section
 155         manager->parseLookup(statement);
 156         manager->parseSelect(statement, manager->primaryKeySize());
 157         manager->cleanup();
 158         /// End locked section
 159
 160         manager->unlock();
 161
 162         m_result->addManager(manager);
 163         m_count = m_result->size();
 164 }
 165
 166 void SelectionMask::parseCount(sqlite3_stmt* statement)
 167 {
 168         Assert(statement);
 169
 170         size_t count = sqlite3_column_int64(statement, 0);
 171         m_count = count;
 172 }
 173
 174 bool SelectionMask::isReachableTable(TableImplPtr table)
 175 {
 176         bool isReachableTable = false;
 177
 178         if(table == m_nativeTable)
 179                 isReachableTable = true;
 180
 181         for(TableImplVector::const_iterator it = m_foreignTables.begin(); it != m_foreignTables.end(); it++)
 182         {
 183                 TableImplPtr foreignTable = *it;
 184                 if(table == foreignTable)
 185                         isReachableTable = true;
 186         }
 187
 188         return isReachableTable;
 189 }