src/DAL/SqliteMgr.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 "SelectionMask.h"
  24 #include "TableImpl.h"
  25 #include "FieldImpl.h"
  26 #include "KeyImpl.h"
  27 #include "KeyValue.h"
  28 #include "Join.h"
  29 #include "SqliteMgr.h"
  30 #include "DatabaseMgr.h"
  31 #include "Statements.h"
  32 #include "StatementStrings.h"
  33 #include "Assert.h"
  34 #include "Global.h"
  35
  36 extern bool g_printsql;
  37
  38 SqliteMgr::SqliteMgr()
  39 {
  40         m_db = DatabaseMgr::Get()->DB();
  41         m_odb = m_db->grabdb();
  42
  43         Assert(m_db);
  44         Assert(m_odb);
  45 }
  46
  47 SqliteMgr::~SqliteMgr()
  48 {
  49         m_db->freedb(m_odb);
  50 }
  51
  52 void SqliteMgr::doInsert(SavableManager* bindable)
  53 {
  54         Assert(bindable);
  55
  56         TableImpl* table = bindable->getTable().get();
  57         Assert(table);
  58
  59         sqlite3_stmt* insert = getInsertStmt(table);
  60         Assert(insert);
  61
  62         sqlite3_reset(insert);
  63
  64         if(table->primarykeysize() > 1)
  65                 bindable->bindKeys(m_odb->db, insert);
  66
  67         doStatement(insert);
  68
  69         if(table->primarykeysize() == 1)
  70                 bindable->parseInsert(m_odb->db);
  71
  72         commit(table);
  73 }
  74
  75 void SqliteMgr::doErase(SavableManager* bindable)
  76 {
  77         Assert(bindable);
  78
  79         TableImpl* table = bindable->getTable().get();
  80         Assert(table);
  81
  82         sqlite3_stmt* erase = getEraseStmt(table);
  83         Assert(erase);
  84
  85         sqlite3_reset(erase);
  86
  87         bindable->bindKeys(m_odb->db, erase);
  88         doStatement(erase);
  89
  90         commit(table);
  91 }
  92
  93 void SqliteMgr::doUpdate(SavableManager* bindable)
  94 {
  95         Assert(bindable);
  96
  97         TableImpl* table = bindable->getTable().get();
  98         Assert(table);
  99
 100         // This table doesn't have any properties, it need not be updated.
 101         if(table->size() <= table->primarykeysize())
 102                 return;
 103
 104         sqlite3_stmt* update = getUpdateStmt(table);
 105         Assert(update);
 106
 107         sqlite3_reset(update);
 108
 109         bindable->bindUpdate(m_odb->db, update);
 110         doStatement(update);
 111
 112         commit(table);
 113 }
 114
 115 void SqliteMgr::doSelect(SavableManager* bindable)
 116 {
 117         Assert(bindable);
 118
 119         TableImpl* table = bindable->getTable().get();
 120         Assert(table);
 121
 122         sqlite3_stmt* select = getSelectStmt(table);
 123         Assert(select);
 124
 125         sqlite3_reset(select);
 126
 127         bindable->bindKeys(m_odb->db, select);
 128         bool row = doStatement(select);
 129         if(row)
 130                 bindable->parseSelect(select);
 131         else
 132                 throw RowNotFoundException("SqliteMgr::doSelect(), no row.");
 133 }
 134
 135 void SqliteMgr::doLookup(SavableManager* bindable, FieldPtr field)
 136 {
 137         Assert(bindable);
 138         Assert(field);
 139
 140         TableImpl* table = bindable->getTable().get();
 141         Assert(table);
 142
 143         sqlite3_stmt* lookup = getLookupStmt(table, field);
 144         Assert(lookup);
 145
 146         sqlite3_reset(lookup);
 147
 148         bindable->bindLookup(m_odb->db, lookup);
 149         bool row = doStatement(lookup);
 150         if(row)
 151         {
 152                 bindable->parseLookup(lookup);
 153                 doSelect(bindable);
 154         }
 155         else
 156                 throw RowNotFoundException("SqliteMgr::doLookup(), no row.");
 157 }
 158
 159 void SqliteMgr::doSelectMulti(SelectionMask* mask)
 160 {
 161         Assert(mask);
 162
 163         sqlite3_stmt* selectMulti = getSelectMultiStmt(mask, false);
 164         Assert(selectMulti);
 165
 166         sqlite3_reset(selectMulti);
 167
 168         mask->bindSelectMulti(m_odb->db, selectMulti);
 169
 170         bool good = true;
 171         for(int i = 0; good; i++)
 172         {
 173                 good = doStatement(selectMulti);
 174                 if(good)
 175                         mask->parseRow(selectMulti);
 176         }
 177
 178         sqlite3_finalize(selectMulti);
 179 }
 180
 181 void SqliteMgr::doCount(SelectionMask* mask)
 182 {
 183         Assert(mask);
 184
 185         sqlite3_stmt* count = getSelectMultiStmt(mask, true);
 186         Assert(count);
 187
 188         sqlite3_reset(count);
 189
 190         mask->bindSelectMulti(m_odb->db, count);
 191
 192         bool good = doStatement(count);
 193
 194         if(good)
 195                 mask->parseCount(count);
 196
 197         sqlite3_finalize(count);
 198 }
 199
 200 void SqliteMgr::commit(TableImpl* table)
 201 {
 202         Assert(table);
 203         m_statements.clear();
 204 }
 205
 206 bool SqliteMgr::doStatement(sqlite3_stmt* stmt)
 207 {
 208         Assert(stmt);
 209
 210         int rc = sqlite3_step(stmt);
 211
 212         switch(rc) {
 213         case SQLITE_DONE:
 214                 return false;
 215         case SQLITE_ROW:
 216                 return true;
 217         }
 218
 219         throw SqliteError(m_odb->db);
 220 }
 221
 222 StatementsPtr SqliteMgr::getStatements(TableImpl* table)
 223 {
 224         Assert(table);
 225
 226         StatementsPtr statements = m_statements[table];
 227         if(statements)
 228                 return statements;
 229
 230         statements = StatementsPtr(new Statements());
 231
 232         m_statements[table] = statements;
 233         return statements;
 234 }
 235
 236 StatementStringsPtr SqliteMgr::getStatementStrings(TableImpl* table)
 237 {
 238         Assert(table);
 239
 240         StatementStringsPtr statements = m_statementstrings[table];
 241         if(statements)
 242                 return statements;
 243
 244         statements = StatementStringsPtr(new StatementStrings());
 245
 246         m_statementstrings[table] = statements;
 247         return statements;
 248 }
 249
 250 sqlite3_stmt* SqliteMgr::getInsertStmt(TableImpl* table)
 251 {
 252         Assert(table);
 253
 254         StatementsPtr statements = getStatements(table);
 255         sqlite3_stmt* statement = statements->getInsert();
 256         if(statement)
 257                 return statement;
 258
 259         std::string sql;
 260
 261         StatementStringsPtr statementstrings = getStatementStrings(table);
 262         cstring statementstring = statementstrings->getInsert();
 263
 264         if(statementstring.size() != 0)
 265         {
 266                 sql = statementstring;
 267         }
 268         else
 269         {
 270                 sql.append("INSERT INTO ");
 271                 sql.append(table->getName());
 272                 sql.append(" (");
 273                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 274                 {
 275                         FieldImplPtr field = *it;
 276                         Assert(field);
 277
 278                         if(!field->isPrimaryKey())
 279                                 continue;
 280
 281                         if(it != table->begin())
 282                                 sql.append(", ");
 283
 284                         sql.append(field->getName());
 285                 }
 286                 sql.append(") VALUES(");
 287                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 288                 {
 289                         FieldImplPtr field = *it;
 290                         Assert(field);
 291
 292                         if(!field->isPrimaryKey())
 293                                 continue;
 294
 295                         if(it != table->begin())
 296                                 sql.append(", ");
 297
 298                         if(table->primarykeysize() == 1)
 299                                 sql.append("NULL");
 300                         else
 301                                 sql.append("?");
 302                 }
 303                 sql.append(");");
 304
 305                 statementstrings->setInsert(sql);
 306         }
 307
 308         if(g_printsql) {
 309                 Global::Get()->printsql(sql);
 310         }
 311
 312         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 313
 314         if(errorcode != SQLITE_OK)
 315                 throw SqliteError(m_odb->db, sql);
 316
 317         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 318
 319         statements->setInsert(statement);
 320         return statement;
 321 }
 322
 323 sqlite3_stmt* SqliteMgr::getEraseStmt(TableImpl* table)
 324 {
 325         StatementsPtr statements = getStatements(table);
 326         sqlite3_stmt* statement = statements->getErase();
 327         if(statement)
 328                 return statement;
 329
 330         std::string sql;
 331
 332         StatementStringsPtr statementstrings = getStatementStrings(table);
 333         cstring statementstring = statementstrings->getErase();
 334
 335         if(statementstring.size() != 0)
 336         {
 337                 sql = statementstring;
 338         }
 339         else
 340         {
 341                 sql.append("DELETE FROM ");
 342                 sql.append(table->getName());
 343                 sql.append(" WHERE ");
 344                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 345                 {
 346                         FieldImplPtr field = *it;
 347                         Assert(field);
 348
 349                         if(!field->isPrimaryKey())
 350                                 continue;
 351
 352                         if(it != table->begin())
 353                                 sql.append(", ");
 354
 355                         sql.append(field->getName());
 356                         sql.append("=?");
 357                 }
 358                 sql.append(";");
 359
 360                 statementstrings->setErase(sql);
 361         }
 362
 363         if(g_printsql) {
 364                 Global::Get()->printsql(sql);
 365         }
 366
 367         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 368
 369         if(errorcode != SQLITE_OK)
 370                 throw SqliteError(m_odb->db, sql);
 371
 372         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 373
 374         statements->setErase(statement);
 375         return statement;
 376 }
 377
 378 sqlite3_stmt* SqliteMgr::getUpdateStmt(TableImpl* table)
 379 {
 380         StatementsPtr statements = getStatements(table);
 381         sqlite3_stmt* statement = statements->getUpdate();
 382         if(statement)
 383                 return statement;
 384
 385         std::string sql;
 386
 387         StatementStringsPtr statementstrings = getStatementStrings(table);
 388         cstring statementstring = statementstrings->getUpdate();
 389
 390         if(statementstring.size() != 0)
 391         {
 392                 sql = statementstring;
 393         }
 394         else
 395         {
 396                 sql.append("UPDATE ");
 397                 sql.append(table->getName());
 398                 sql.append(" SET ");
 399
 400                 bool comspace = false;
 401                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 402                 {
 403                         FieldImplPtr field = *it;
 404                         Assert(field);
 405
 406                         if(field->isPrimaryKey())
 407                                 continue;
 408
 409                         if(comspace)
 410                                 sql.append(", ");
 411
 412                         sql.append(field->getName());
 413                         sql.append("=?");
 414
 415                         comspace = true;
 416                 }
 417                 sql.append(" WHERE ");
 418                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 419                 {
 420                         FieldImplPtr field = *it;
 421                         Assert(field);
 422
 423                         if(!field->isPrimaryKey())
 424                                 continue;
 425
 426                         if(it != table->begin())
 427                                 sql.append(" AND ");
 428
 429                         sql.append(field->getName());
 430                         sql.append("=?");
 431                 }
 432                 sql.append(";");
 433
 434                 statementstrings->setUpdate(sql);
 435         }
 436
 437         if(g_printsql) {
 438                 Global::Get()->printsql(sql);
 439         }
 440
 441         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 442
 443         if(errorcode != SQLITE_OK)
 444                 throw SqliteError(m_odb->db, sql);
 445
 446         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 447
 448         statements->setUpdate(statement);
 449         return statement;
 450 }
 451
 452 sqlite3_stmt* SqliteMgr::getSelectStmt(TableImpl* table)
 453 {
 454         StatementsPtr statements = getStatements(table);
 455         sqlite3_stmt* statement = statements->getSelect();
 456         if(statement)
 457                 return statement;
 458
 459         std::string sql;
 460
 461         StatementStringsPtr statementstrings = getStatementStrings(table);
 462         cstring statementstring = statementstrings->getSelect();
 463
 464         if(statementstring.size() != 0)
 465         {
 466                 sql = statementstring;
 467         }
 468         else
 469         {
 470                 sql.append("SELECT ");
 471
 472                 bool comspace = false;
 473                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 474                 {
 475                         FieldImplPtr field = *it;
 476                         Assert(field);
 477
 478                         if(field->isPrimaryKey())
 479                                 continue;
 480
 481                         if(comspace)
 482                                 sql.append(", ");
 483
 484                         sql.append(field->getName());
 485                         comspace = true;
 486                 }
 487
 488                 /**
 489                  * Prevent queries in the form "SELECT  FROM ....", this is for tables that consist of only primary keys.
 490                  */
 491                 if(table->primarykeysize() == table->size())
 492                         sql.append("*");
 493
 494                 sql.append(" FROM ");
 495                 sql.append(table->getName());
 496                 sql.append(" WHERE ");
 497
 498                 bool andspace = false;
 499                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 500                 {
 501                         FieldImplPtr field = *it;
 502                         Assert(field);
 503
 504                         if(!field->isPrimaryKey())
 505                                 continue;
 506
 507                         if(andspace)
 508                                 sql.append(" AND ");
 509
 510                         sql.append(field->getName());
 511                         sql.append("=?");
 512                         andspace = true;
 513                 }
 514                 sql.append(";");
 515
 516                 statementstrings->setSelect(sql);
 517         }
 518
 519         if(g_printsql) {
 520                 Global::Get()->printsql(sql);
 521         }
 522
 523         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 524
 525         if(errorcode != SQLITE_OK)
 526                 throw SqliteError(m_odb->db, sql);
 527
 528         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 529
 530         statements->setSelect(statement);
 531         return statement;
 532 }
 533
 534 sqlite3_stmt* SqliteMgr::getLookupStmt(TableImpl* table, FieldPtr lookupfield)
 535 {
 536         StatementsPtr statements = getStatements(table);
 537         sqlite3_stmt* statement = statements->getLookup(lookupfield);
 538         if(statement)
 539                 return statement;
 540
 541         std::string sql;
 542
 543         StatementStringsPtr statementstrings = getStatementStrings(table);
 544         cstring statementstring = statementstrings->getLookup(lookupfield);
 545
 546         if(statementstring.size() != 0)
 547         {
 548                 sql = statementstring;
 549         }
 550         else
 551         {
 552                 sql.append("SELECT ");
 553                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 554                 {
 555                         FieldImplPtr field = *it;
 556                         Assert(field);
 557
 558                         if(it != table->begin())
 559                                 sql.append(", ");
 560
 561                         sql.append(field->getName());
 562                 }
 563                 sql.append(" FROM ");
 564                 sql.append(table->getName());
 565                 sql.append(" WHERE ");
 566                 sql.append(lookupfield->getName());
 567                 sql.append("=?");
 568                 sql.append(";");
 569
 570                 statementstrings->setLookup(lookupfield, sql);
 571         }
 572
 573         if(g_printsql) {
 574                 Global::Get()->printsql(sql);
 575         }
 576
 577         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 578
 579         if(errorcode != SQLITE_OK)
 580                 throw SqliteError(m_odb->db, sql);
 581
 582         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 583
 584         statements->setLookup(lookupfield, statement);
 585         return statement;
 586 }
 587
 588 sqlite3_stmt* SqliteMgr::getSelectMultiStmt(SelectionMask* mask, bool count)
 589 {
 590         Assert(mask);
 591
 592         std::string sql;
 593         sqlite3_stmt* statement;
 594
 595         TableImplPtr table = mask->getTable();
 596         Assert(table);
 597
 598         sql.append("SELECT ");
 599
 600         if(count) {
 601                 sql.append("COUNT(*)");
 602         }
 603         else
 604         {
 605                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 606                 {
 607                         FieldImplPtr field = *it;
 608                         Assert(field);
 609
 610                         if(it != table->begin())
 611                                 sql.append(", ");
 612
 613                         sql.append(field->getTable()->getName());
 614                         sql.append(".");
 615                         sql.append(field->getName());
 616                 }
 617         }
 618
 619         sql.append(" FROM ");
 620         sql.append(table->getName());
 621
 622         /**
 623          * Allow for queries that retreive data from foreigh tables "SELECT a, b, c, FROM Table INNER JOIN Other ON tableid = fkTable WHERE d = 5;"
 624          */
 625         for(Joins::const_iterator it = mask->joinsbegin(); it != mask->joinsend(); it++)
 626         {
 627                 JoinPtr join = *it;
 628                 sql.append(" INNER JOIN ");
 629                 sql.append(join->getJoinTable()->getName());
 630                 sql.append(" ON ");
 631                 sql.append(join->getNativeKey()->getName());
 632                 sql.append(" = ");
 633                 sql.append(join->getForeignKey()->getName());
 634         }
 635
 636         /**
 637          * Prevent queries in the form "SELECT a, b, c FROM table WHERE ;", this is for the unmasked selection.
 638          */
 639         if(mask->size())
 640                 sql.append(" WHERE ");
 641
 642         for(Strings::const_iterator it = mask->begin(); it != mask->end(); it++)
 643         {
 644                 if(it != mask->begin())
 645                         sql.append(" AND ");
 646
 647                 sql.append(*it);
 648                 sql.append("=?");
 649         }
 650         sql.append(";");
 651
 652         if(g_printsql) {
 653                 Global::Get()->printsql(sql);
 654         }
 655
 656         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 657
 658         if(errorcode != SQLITE_OK)
 659                 throw SqliteError(m_odb->db, sql);
 660
 661         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 662
 663         return statement;
 664 }
 665
 666 bool SqliteMgr::databasePopulated()
 667 {
 668         std::string sql("SELECT * FROM SQLITE_MASTER;");
 669
 670         if(g_printsql) {
 671                 Global::Get()->printsql(sql);
 672         }
 673
 674         sqlite3_stmt* statement;
 675         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 676
 677         if(errorcode != SQLITE_OK)
 678                 throw SqliteError(m_odb->db, sql);
 679
 680         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 681
 682         bool populated = doStatement(statement);
 683         sqlite3_finalize(statement);
 684
 685         return populated;
 686 }
 687
 688 bool SqliteMgr::tableValid(TableImplPtr table)
 689 {
 690         Assert(table);
 691
 692         std::string sql = tableQuery(table);
 693
 694         if(g_printsql) {
 695                 Global::Get()->printsql(sql);
 696         }
 697
 698         sqlite3_stmt* statement;
 699         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 700
 701         if(errorcode != SQLITE_OK)
 702                 throw SqliteError(m_odb->db, sql);
 703
 704         bool success = doStatement(statement);
 705         sqlite3_finalize(statement);
 706
 707         return success;
 708 }
 709
 710 void SqliteMgr::initTable(TableImplPtr table)
 711 {
 712         Assert(table);
 713
 714         std::string sql = SqliteMgr::Get()->creationQuery(table);
 715
 716         if(g_printsql) {
 717                 Global::Get()->printsql(sql);
 718         }
 719
 720         sqlite3_stmt* statement;
 721         int errorcode = sqlite3_prepare_v2(m_odb->db, sql.c_str(), (int)sql.size(), &statement, &m_leftover);
 722
 723         if(errorcode != SQLITE_OK)
 724                 throw SqliteError(m_odb->db, sql);
 725
 726         Assert(m_leftover == NULL || strlen(m_leftover) == 0);
 727         doStatement(statement);
 728         sqlite3_finalize(statement);
 729
 730         return;
 731 }
 732
 733 std::string SqliteMgr::tableQuery(TableImplPtr table) const
 734 {
 735         Assert(table);
 736
 737         std::string result;
 738         result.append("SELECT type FROM sqlite_master WHERE tbl_name='");
 739         result.append(table->getName());
 740         result.append("' and sql='");
 741
 742         result.append(creationQuery(table, true));
 743
 744         result.append("';");
 745
 746         return result;
 747 }
 748
 749 /*
 750         "CREATE TABLE IF NOT EXISTS %s("
 751         "%s INTEGER PRIMARY KEY AUTOINCREMENT"
 752         ",versiontext TEXT"
 753         ",grantgroup INTEGER RESTRAINT grantgroup DEFAULT 1"
 754         ");",
 755 */
 756 std::string SqliteMgr::creationQuery(TableImplPtr table, bool verify) const
 757 {
 758         Assert(table);
 759
 760         std::string result;
 761
 762         if(verify)
 763                 result.append("CREATE TABLE ");
 764         else
 765                 result.append("CREATE TABLE IF NOT EXISTS ");
 766
 767         result.append(table->getName());
 768         result.append("(");
 769
 770         for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 771         {
 772                 FieldImplPtr field = *it;
 773                 Assert(field);
 774
 775                 bool psk = (field->isPrimaryKey() && table->primarykeysize() == 1);
 776
 777                 if(it != table->begin())
 778                         result.append(", ");
 779
 780                 result.append(field->getName());
 781
 782                 if(field->isText()) {
 783                         result.append(" TEXT");
 784                 }
 785                 else
 786                 {
 787                         result.append(" INTEGER");
 788
 789                         if(psk)
 790                                 result.append(" PRIMARY KEY AUTOINCREMENT");
 791                 }
 792
 793                 if(field->isLookup() && !psk)
 794                 {
 795                         result.append(" RESTRAINT ");
 796                         result.append(field->getName());
 797                         result.append(" UNIQUE");
 798                 }
 799
 800                 std::string defaultvalue = field->getDefaultValue();
 801
 802                 if(defaultvalue.size() != 0)
 803                 {
 804                         Assert(!field->isLookup());
 805                         Assert(!psk);
 806
 807                         result.append(" RESTRAINT ");
 808                         result.append(field->getName());
 809                         result.append(" DEFAULT ");
 810
 811                         if(field->isText())
 812                                 result.append("'");
 813
 814                         result.append(defaultvalue);
 815
 816                         if(field->isText())
 817                                 result.append("'");
 818                 }
 819         }
 820
 821         if(table->primarykeysize() > 1)
 822         {
 823                 result.append(", PRIMARY KEY(");
 824
 825                 bool comspace = false;
 826                 for(FieldImplVector::const_iterator it = table->begin(); it != table->end(); it++)
 827                 {
 828                         FieldImplPtr field = *it;
 829                         Assert(field);
 830
 831                         if(!field->isPrimaryKey())
 832                                 continue;
 833
 834                         if(comspace)
 835                                 result.append(", ");
 836
 837                         result.append(field->getName());
 838                         comspace = true;
 839                 }
 840                 result.append(")");
 841         }
 842
 843         result.append(")");
 844
 845         if(!verify)
 846                 result.append(";");
 847
 848         return result;
 849 }
 850
 851 std::string SqliteMgr::creationString(FieldImplPtr field) const
 852 {
 853         Assert(field);
 854
 855         std::string result = field->getName();
 856
 857         if(field->isText())
 858                 result.append(" TEXT");
 859         else
 860                 result.append(" INTEGER");
 861
 862         if(field->getDefaultValue().size() != 0)
 863         {
 864                 result.append(" RESTRAINT ");
 865                 result.append(field->getName());
 866                 result.append(" DEFAULT ");
 867
 868                 if(field->isText())
 869                         result.append("'");
 870                 result.append(field->getDefaultValue());
 871                 if(field->isText())
 872                         result.append("'");
 873         }
 874
 875         return result;
 876 }