src/DAL/SavableManager.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 "SavableManager.h"
  22 #include "SavableManagers.h"
  23 #include "FieldValue.h"
  24 #include "FieldValues.h"
  25 #include "KeyValue.h"
  26 #include "Keys.h"
  27 #include "KeyImpl.h"
  28 #include "FieldImpl.h"
  29 #include "TableImpl.h"
  30 #include "SqliteMgr.h"
  31 #include "StringUtilities.h"
  32 #include "SelectionMask.h"
  33 #include "Relation.h"
  34 #include "Join.h"
  35
  36 ByKeyCache SavableManager::ms_byKeyCache;
  37 ByValueCache SavableManager::ms_byValueCache;
  38
  39 SavableManager::SavableManager(TableImplPtr table) :
  40 m_table(table),
  41 m_newentry(true),
  42 m_locked(false)
  43 {
  44         Assert(table);
  45
  46         for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
  47         {
  48                 FieldImplPtr field = *it;
  49                 Assert(field);
  50
  51                 m_fields[it->get()] = field->newValue();
  52         }
  53 }
  54
  55 SavableManager::~SavableManager()
  56 {
  57
  58 }
  59
  60 SavableManagersPtr SavableManager::getmulti(FieldValuesPtr values) // static
  61 {
  62         Assert(values);
  63
  64         Joins joins;
  65         return getmulti(values, joins);
  66 }
  67
  68 SavableManagersPtr SavableManager::getmulti(FieldValuesPtr values, const Joins& joins) // static
  69 {
  70         Assert(values);
  71
  72         TableImplPtr table = values->getTable();
  73         Assert(table);
  74
  75         SelectionMaskPtr mask(new SelectionMask(table));
  76
  77         for(ValueMap::const_iterator it = values->begin(); it != values->end(); it++)
  78         {
  79                 ValuePtr value = it->second;
  80                 mask->addField(value);
  81         }
  82
  83         for(Joins::const_iterator it = joins.begin(); it != joins.end(); it++)
  84         {
  85                 JoinPtr join = *it;
  86                 mask->addJoin(join);
  87         }
  88
  89         return getmulti(mask);
  90 }
  91
  92 SavableManagersPtr SavableManager::getmulti(SelectionMaskPtr mask) // static
  93 {
  94         Assert(mask);
  95
  96         SqliteMgr::Get()->doSelectMulti(mask.get());
  97         return mask->getResult();
  98 }
  99
 100 SavableManagerPtr SavableManager::getnew(TableImplPtr table) // static
 101 {
 102         Assert(table);
 103
 104         SavableManagerPtr result(new SavableManager(table));
 105         return result;
 106 }
 107
 108 SavableManagerPtr SavableManager::bykey(KeyValuePtr key) // static
 109 {
 110         Assert(key);
 111
 112         TableImplPtr table = key->getTable();
 113         KeysPtr keys(new Keys(table));
 114         keys->addKey(key);
 115         return bykeys(keys);
 116 }
 117
 118 SavableManagerPtr SavableManager::bykeys(KeysPtr keys) // static
 119 {
 120         Assert(keys);
 121
 122         KeyFieldMap map = constructMap(keys);
 123
 124         if(ms_byKeyCache.find(map) == ms_byKeyCache.end())
 125         {
 126                 SavableManagerPtr result = getnew(keys->getTable());
 127
 128                 bool locked = result->lock(); // new object, should always be unlocked
 129                 Assert(locked);
 130
 131                 /// Begin locked section
 132                 result->setKeys(keys);
 133                 SqliteMgr::Get()->doSelect(result.get());
 134                 doFullCache(result);
 135                 result->cleanup();
 136                 /// End locked section
 137
 138                 result->unlock();
 139         }
 140
 141         SavableManagerPtr result = ms_byKeyCache[map];
 142         Assert(result);
 143
 144         return result;
 145 }
 146
 147 SavableManagerPtr SavableManager::byvalue(ValuePtr value) // static
 148 {
 149         Assert(value);
 150
 151         FieldImplPtr field = value->getField();
 152         Assert(field);
 153         Assert(field->isLookup());
 154
 155         TextFieldPair pair = constructPair(value);
 156
 157         if(ms_byValueCache.find(pair) == ms_byValueCache.end())
 158         {
 159                 SavableManagerPtr result = getnew(value->getTable());
 160
 161                 bool locked = result->lock(); // new object, should always be unlocked
 162                 Assert(locked);
 163
 164                 /// Begin locked section
 165                 result->m_lookupvalue = value;
 166                 SqliteMgr::Get()->doLookup(result.get(), value->getField());
 167                 doFullCache(result);
 168                 result->cleanup();
 169                 /// End locked section
 170
 171                 result->unlock();
 172         }
 173
 174         SavableManagerPtr result = ms_byValueCache[pair];
 175         Assert(result);
 176
 177         return result;
 178 }
 179
 180 KeysPtr SavableManager::lookupvalue(ValuePtr value) // static
 181 {
 182         Assert(value);
 183
 184         SavableManagerPtr result = byvalue(value);
 185         KeysPtr keys = result->getKeys();
 186         return keys;
 187 }
 188
 189
 190 size_t SavableManager::count(SelectionMaskPtr mask)
 191 {
 192         Assert(mask);
 193
 194         SqliteMgr::Get()->doCount(mask.get());
 195         return mask->getCount();
 196 }
 197
 198 size_t SavableManager::count(KeysPtr keys)
 199 {
 200         Assert(keys);
 201         Assert(keys->size() == keys->getTable()->primarykeysize());
 202
 203         TableImplPtr table = keys->getTable();
 204         Assert(table);
 205
 206         SelectionMaskPtr mask(new SelectionMask(table));
 207
 208         for(KeyImplMap::const_iterator it = keys->begin(); it != keys->end(); it++)
 209         {
 210                 KeyValuePtr key = it->second;
 211                 Assert(key);
 212
 213                 mask->addField(key);
 214         }
 215
 216         return count(mask);
 217 }
 218
 219 void SavableManager::doFullCache(SavableManagerPtr manager) // static
 220 {
 221         Assert(manager);
 222
 223         Assert(manager->primaryKeySize() == manager->getTable()->primarykeysize());
 224
 225         KeyFieldMap map = constructMap(manager);
 226         ms_byKeyCache[map] = manager;
 227
 228         for(FieldImplVector::const_iterator it = manager->getTable()->begin(); it != manager->getTable()->end(); it++)
 229         {
 230                 FieldImplPtr field = *it;
 231                 Assert(field);
 232
 233                 if(!field->isLookup())
 234                         continue;
 235
 236                 ValuePtr value = manager->getValue(field);
 237                 Assert(value);
 238
 239                 TextFieldPair pair = constructPair(value);
 240
 241                 // Don't allow overwriting a previous value, unless it pointed to us.
 242                 Assert((ms_byValueCache.find(pair) == ms_byValueCache.end()) || (ms_byValueCache[pair] == manager));
 243                 ms_byValueCache[pair] = manager;
 244         }
 245 }
 246
 247 void SavableManager::doUncache(SavableManagerPtr manager) // static
 248 {
 249         Assert(manager);
 250
 251         for(FieldImplVector::const_iterator it = manager->getTable()->begin(); it != manager->getTable()->end(); it++)
 252         {
 253                 FieldImplPtr field = *it;
 254                 Assert(field);
 255
 256                 if(!field->isLookup())
 257                         continue;
 258
 259                 FieldImpl* fieldptr = field.get();
 260                 Assert(fieldptr);
 261
 262                 FieldValuePtr value = manager->m_orig[fieldptr];
 263
 264                 // Check if it was a new value
 265                 if(!value)
 266                         continue;
 267
 268                 TextFieldPair pair = constructPair(value);
 269
 270                 // Assert that any previous values reference us
 271                 Assert((ms_byValueCache.find(pair) == ms_byValueCache.end()) || (ms_byValueCache[pair] == manager));
 272                 ms_byValueCache.erase(pair);
 273         }
 274 }
 275
 276 void SavableManager::doRecache(SavableManagerPtr manager)
 277 {
 278         doUncache(manager);
 279         doFullCache(manager);
 280 }
 281
 282 KeyFieldMap SavableManager::constructMap(KeysPtr keys) // static
 283 {
 284         KeyFieldMap result;
 285         for(KeyImplMap::const_iterator it = keys->begin(); it != keys->end(); it++)
 286                 result[it->first] = it->second->getIntegerValue();
 287
 288         return result;
 289 }
 290
 291 KeyFieldMap SavableManager::constructMap(SavableManagerPtr manager) // static
 292 {
 293         KeyFieldMap result;
 294
 295         for(FieldImplVector::const_iterator it = manager->getTable()->begin(); it != manager->getTable()->end(); it++)
 296         {
 297                 FieldImplPtr field = *it;
 298                 Assert(field);
 299
 300                 if(!field->isPrimaryKey())
 301                         continue;
 302
 303                 FieldValuePtr fieldvalue = manager->getValue(field);
 304                 Assert(fieldvalue);
 305
 306                 KeyValuePtr key = boost::static_pointer_cast<KeyValue>(fieldvalue);
 307                 Assert(key);
 308
 309                 KeyImplPtr keyimpl = key->getKeyImpl();
 310                 Assert(keyimpl);
 311
 312                 result[keyimpl.get()] = key->getIntegerValue();
 313         }
 314
 315         return result;
 316 }
 317
 318 TextFieldPair SavableManager::constructPair(ValuePtr value) // static
 319 {
 320         TextFieldPair result;
 321         FieldImplPtr field = value->getField();
 322
 323         result.first = field.get();
 324         if(field->isText())
 325                 result.second = value->getStringValue();
 326         else
 327                 result.second = String::Get()->fromInt(value->getIntegerValue());
 328
 329         return result;
 330 }
 331
 332 std::string SavableManager::fromMap(const KeyFieldMap& map) // static
 333 {
 334         Strings result;
 335         std::string tablename;
 336
 337         for(std::map<KeyImpl*, value_type>::const_iterator it = map.begin(); it != map.end(); it++)
 338         {
 339                 KeyImpl* key = it->first;
 340                 value_type value = it->second;
 341
 342                 TableImplPtr table = key->getTable();
 343                 Assert(table);
 344
 345                 tablename = table->getName();
 346
 347                 std::string line = key->getName();
 348                 line.append(": ");
 349                 line.append(String::Get()->fromInt(value));
 350
 351                 result.push_back(line);
 352         }
 353
 354         std::string name("Keys from table ");
 355         name.append(tablename);
 356
 357         return String::Get()->box(result, name);
 358 }
 359
 360 void SavableManager::erase()
 361 {
 362         Assert(m_locked);
 363
 364         if(m_newentry)
 365                 return;
 366
 367         SqliteMgr::Get()->doErase(this);
 368         doUncache(shared_from_this());
 369 }
 370
 371 void SavableManager::save()
 372 {
 373         Assert(m_locked);
 374
 375         if(m_newentry)
 376         {
 377                 SqliteMgr::Get()->doInsert(this);
 378                 doFullCache(shared_from_this());
 379                 m_newentry = false;
 380         }
 381
 382         if(m_orig.size() > 0)
 383         {
 384                 SqliteMgr::Get()->doUpdate(this);
 385                 doRecache(shared_from_this());
 386                 cleanup();
 387         }
 388 }
 389
 390 void SavableManager::discard()
 391 {
 392         Assert(m_locked);
 393
 394         SqliteMgr::Get()->doSelect(this);
 395         cleanup();
 396 }
 397
 398 bool SavableManager::exists() const
 399 {
 400         if(m_newentry)
 401                 return false;
 402
 403         return true;
 404 }
 405
 406 bool SavableManager::lock()
 407 {
 408         if(m_locked)
 409                 return false;
 410
 411         m_locked = true;
 412         return true;
 413 }
 414
 415 void SavableManager::unlock()
 416 {
 417         Assert(m_locked);
 418
 419         m_locked = false;
 420 }
 421
 422 void SavableManager::bindKeys(sqlite3* db, sqlite3_stmt* stmt, const int startpos) const
 423 {
 424         Assert(db);
 425         Assert(stmt);
 426
 427         int pos = startpos;
 428         int rc = 0;
 429         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 430         {
 431                 FieldImplPtr field = *it;
 432                 Assert(field);
 433
 434                 if(!field->isPrimaryKey())
 435                         continue;
 436
 437                 FieldValuePtr fieldvalue = getValue(field);
 438                 Assert(fieldvalue);
 439
 440                 value_type value = fieldvalue->getIntegerValue();
 441
 442                 rc = sqlite3_bind_int64(stmt, pos, value);
 443
 444                 if(rc != SQLITE_OK)
 445                         throw SqliteError(db);
 446
 447                 pos++;
 448         }
 449 }
 450
 451 void SavableManager::bindFields(sqlite3* db, sqlite3_stmt* stmt, const int startpos) const
 452 {
 453         Assert(db);
 454         Assert(stmt);
 455
 456         int pos = startpos;
 457         int rc = 0;
 458         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 459         {
 460                 FieldImplPtr field = *it;
 461                 Assert(field);
 462
 463                 if(field->isPrimaryKey())
 464                         continue;
 465
 466                 if(field->isText())
 467                 {
 468                         FieldValuePtr value = getValue(field);
 469                         std::string stringvalue = value->getStringValue();
 470                         rc = sqlite3_bind_text(stmt, pos, stringvalue.c_str(), stringvalue.size(), SQLITE_TRANSIENT);
 471                 }
 472                 else
 473                 {
 474                         FieldValuePtr value = getValue(field);
 475                         value_type integervalue = value->getIntegerValue();
 476                         rc = sqlite3_bind_int64(stmt, pos, integervalue);
 477                 }
 478
 479                 if(rc != SQLITE_OK)
 480                         throw SqliteError(db);
 481                 pos++;
 482         }
 483 }
 484
 485 void SavableManager::bindUpdate(sqlite3* db, sqlite3_stmt* stmt) const
 486 {
 487         Assert(db);
 488         Assert(stmt);
 489
 490         bindFields(db, stmt);
 491         bindKeys(db, stmt, m_fields.size() - primaryKeySize() + 1);
 492 }
 493
 494 void SavableManager::bindLookup(sqlite3* db, sqlite3_stmt* stmt) const
 495 {
 496         Assert(db);
 497         Assert(stmt);
 498
 499         int rc = 0;
 500         if(m_lookupvalue->getField()->isText())
 501                 rc = sqlite3_bind_text(stmt, 1, m_lookupvalue->getStringValue().c_str(), m_lookupvalue->getStringValue().size(), SQLITE_TRANSIENT);
 502         else
 503                 rc = sqlite3_bind_int64(stmt, 1, m_lookupvalue->getIntegerValue());
 504
 505         if(rc != SQLITE_OK)
 506                 throw SqliteError(db);
 507 }
 508
 509 void SavableManager::parseInsert(sqlite3* db)
 510 {
 511         Assert(m_locked);
 512         Assert(db);
 513         Assert(m_table->primarykeysize() == 1);
 514
 515         FieldImplPtr field = m_table->firstkey();
 516         Assert(field);
 517
 518         value_type value = sqlite3_last_insert_rowid(db);
 519
 520         FieldValuePtr key = field->newValue();
 521         Assert(key->isKey());
 522
 523         key->setIntegerValue(value);
 524
 525         setValue(key);
 526 }
 527
 528 void SavableManager::parseSelect(sqlite3_stmt* stmt, const int startpos)
 529 {
 530         Assert(m_locked);
 531         Assert(stmt);
 532
 533         int pos = startpos;
 534         const unsigned char * text;
 535         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 536         {
 537                 FieldImplPtr field = *it;
 538                 Assert(field);
 539
 540                 if(field->isPrimaryKey())
 541                         continue;
 542
 543                 if(field->isText())
 544                 {
 545                         text = sqlite3_column_text(stmt, pos);
 546                         if(text != 0)
 547                         {
 548                                 std::string value = std::string((const char *)text);
 549
 550                                 FieldValuePtr fieldvalue = getValue(field);
 551                                 getValue(field)->setTextValue(value);
 552                         }
 553                 }
 554                 else
 555                 {
 556                         value_type value =  sqlite3_column_int64(stmt, pos);
 557                         FieldValuePtr fieldvalue = getValue(field);
 558                         getValue(field)->setIntegerValue(value);
 559                 }
 560
 561                 pos++;
 562         }
 563
 564         m_newentry = false;
 565 }
 566
 567 void SavableManager::parseLookup(sqlite3_stmt* stmt)
 568 {
 569         Assert(m_locked);
 570         Assert(stmt);
 571
 572         int pos = 0;
 573         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 574         {
 575                 FieldImplPtr field = *it;
 576                 Assert(field);
 577
 578                 if(!field->isPrimaryKey())
 579                         continue;
 580
 581                 KeyImplPtr key = boost::static_pointer_cast<KeyImpl>(field);
 582                 Assert(key);
 583
 584                 setValue(key, sqlite3_column_int64(stmt, pos));
 585                 pos++;
 586         }
 587 }
 588
 589 TableImplPtr SavableManager::getTable() const
 590 {
 591         return m_table;
 592 }
 593
 594 size_t SavableManager::primaryKeySize() const
 595 {
 596         size_t keysize = 0;
 597
 598         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 599         {
 600                 FieldImplPtr field = *it;
 601                 Assert(field);
 602
 603                 if(!field->isPrimaryKey())
 604                         continue;
 605
 606                 keysize++;
 607         }
 608
 609         return keysize;
 610 }
 611
 612 KeysPtr SavableManager::getKeys() const
 613 {
 614         KeysPtr result(new Keys(m_table));
 615
 616         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 617         {
 618                 FieldImplPtr field = *it;
 619                 Assert(field);
 620
 621                 if(!field->isPrimaryKey())
 622                         continue;
 623
 624                 FieldValuePtr value = getValue(field);
 625                 Assert(value);
 626
 627                 KeyValuePtr key = boost::static_pointer_cast<KeyValue>(value);
 628                 Assert(key);
 629
 630                 Assert(key->isKey());
 631                 result->addKey(key);
 632         }
 633
 634         return result;
 635 }
 636
 637 ValuePtr SavableManager::getValue(FieldImplPtr field) const
 638 {
 639         Assert(field);
 640
 641         FieldValueMap::const_iterator it = m_fields.find(field.get());
 642         Assert(it != m_fields.end());
 643
 644         return it->second;
 645 }
 646
 647 std::string SavableManager::getDiff() const
 648 {
 649         std::vector<std::string> result;
 650
 651         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 652         {
 653                 FieldImplPtr field = *it;
 654                 Assert(field);
 655
 656                 // Check if the field has been changed
 657                 FieldValueMap::const_iterator it = m_orig.find(field.get());
 658                 if(it == m_orig.end())
 659                         continue;
 660
 661                 // Retreive the original value.
 662                 FieldValuePtr origValue = it->second;
 663                 Assert(origValue);
 664
 665                 // Retreive the current value.
 666                 FieldValuePtr currentValue = getValue(field);
 667                 Assert(currentValue);
 668
 669                 std::string line = "Changed field '";
 670                 if(field->isKey() && !field->isPrimaryKey())
 671                         line.append(field->getName().substr(2));
 672                 else
 673                         line.append(field->getName());
 674                 line.append("' from '");
 675
 676                 if(field->isText())
 677                         line.append(origValue->getStringValue());
 678                 else
 679                         line.append(String::Get()->fromInt(origValue->getIntegerValue()));
 680
 681                 line.append("' to '");
 682
 683                 if(field->isText())
 684                         line.append(currentValue->getStringValue());
 685                 else
 686                         line.append(String::Get()->fromInt(currentValue->getIntegerValue()));
 687
 688                 line.append("'.");
 689
 690                 result.push_back(line);
 691         }
 692
 693         return String::Get()->unlines(result, "\n", 0);
 694 }
 695
 696 bool SavableManager::isDirty() const
 697 {
 698         return m_orig.size() > 0;
 699 }
 700
 701 void SavableManager::setKeys(KeysPtr keys)
 702 {
 703         Assert(m_locked);
 704         Assert(keys);
 705         Assert(keys->size() == m_table->primarykeysize());
 706
 707         for(KeyImplMap::const_iterator it = keys->begin(); it != keys->end(); it++) {
 708                 Assert(it->first->getTable() == m_table);
 709                 setValue(it->second);
 710         }
 711 }
 712
 713 void SavableManager::setValue(FieldValuePtr value)
 714 {
 715         Assert(m_locked);
 716         Assert(value);
 717         Assert(value->getTable() == m_table);
 718
 719         FieldImpl* field = value->getField().get();
 720         Assert(field);
 721
 722         Assert(m_fields.find(field) != m_fields.end());
 723
 724         // Store the original value in m_orig
 725         if(m_orig.find(field) == m_orig.end())
 726                 m_orig[field] = m_fields[field];
 727
 728         m_fields[field] = value;
 729 }
 730
 731 void SavableManager::setValue(FieldImplPtr field, cstring value) // delegator
 732 {
 733         FieldValuePtr fieldvalue(new FieldValue(field, value));
 734         setValue(fieldvalue);
 735 }
 736
 737 void SavableManager::setValue(FieldImplPtr field, value_type value) // delegator
 738 {
 739         FieldValuePtr fieldvalue(new FieldValue(field, value));
 740         setValue(fieldvalue);
 741 }
 742
 743 void SavableManager::setValue(KeyImplPtr field, value_type value) // delegator
 744 {
 745         KeyValuePtr fieldvalue(new KeyValue(field, value));
 746         setValue(fieldvalue);
 747 }
 748
 749 void SavableManager::cleanup()
 750 {
 751         Assert(m_locked);
 752
 753         m_orig.clear();
 754 }
 755
 756 std::string SavableManager::toString()
 757 {
 758         std::string name = getTable()->getName();
 759         name.append(" <");
 760         name.append(getKeys()->toString());
 761         name.append(">");
 762
 763         Strings fieldlist;
 764
 765         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 766         {
 767                 FieldImplPtr field = *it;
 768                 Assert(field);
 769
 770                 ValuePtr value = getValue(field);
 771                 Assert(value);
 772
 773                 std::string line = field->getName();
 774                 line.append(": ");
 775
 776                 if(field->isText())
 777                         line.append(value->getStringValue());
 778                 else
 779                         line.append(String::Get()->fromInt(value->getIntegerValue()));
 780
 781                 fieldlist.push_back(line);
 782         }
 783
 784         return String::Get()->box(fieldlist, name);
 785 }
 786
 787 Strings SavableManager::fieldList() const
 788 {
 789         Strings result;
 790
 791         for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
 792         {
 793                 FieldImplPtr field = *it;
 794                 Assert(field);
 795
 796                 ValuePtr value = getValue(field);
 797
 798                 if(field->isText()) {
 799                         result.push_back(value->getStringValue());
 800                 }
 801                 else
 802                 {
 803                         // TODO lookup foreign keys
 804                         /*
 805                         if(field->isKey())
 806                         {
 807                                 int keyvalue = value->getIntegerValue();
 808
 809                                 KeyImplPtr keyimpl = boost::static_pointer_cast<KeyImpl>(field);
 810                                 KeyValuePtr key(new KeyValue(keyimpl, keyvalue));
 811
 812                                 try {
 813                                         SavableManagerPtr manager = SavableManager::bykey(key);
 814                                 } catch(RowNotFoundException& e) {
 815                                         // TODO handle
 816                                 }
 817
 818                                 // result.push_back(manager->getfield(manager->getIdentifyingField())->getStringValue());
 819                                 // TODO
 820                                 // continue;
 821                         }
 822                         */
 823
 824                         result.push_back(String::Get()->fromInt(value->getIntegerValue()));
 825                 }
 826         }
 827
 828         return result;
 829 }