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