00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
#ifdef WIN32
00025
#include <Config-win.h>
00026
#endif
00027
#include <libfd.h>
00028
00029 namespace db {
00030
00035 Category::Category(Database *db)
00036 {
00037
database = db;
00038
new_object = 1;
00039
clear();
00040 }
00041
00042
00043 Category::Category(Database *db,
const std::string& sql)
00044 {
00045
database = db;
00046
new_object = 1;
00047
spawn(sql);
00048 }
00049
00050
00051 Category::Category(Database *db,Query *qd,
int offset)
00052 {
00053
database = db;
00054
new_object = 0;
00055
spawn(qd, offset);
00056 }
00057
00058
00059 Category::Category(Database& db,
long i_num):database(&db),new_object(1)
00060 {
00061 Query q(*
database);
00062 std::string sql =
"select * from category where ";
00063 {
00064
char slask[100];
00065 sprintf(slask,
"num='%ld'",i_num);
00066 sql += slask;
00067 }
00068
spawn(sql);
00069 }
00070
00071
00072 Category::~Category()
00073 {
00074 }
00075
00076
00077 void Category::select(
const std::string& sql)
00078 {
00079
spawn(sql);
00080 }
00081
00082
00083 my_ulonglong Category::insert()
00084 {
00085 Query q(*
database);
00086 std::string sql;
00087
00088 sql =
"insert into category(num,name)";
00089 {
00090
char slask[100];
00091 sprintf(slask,
" values(%ld",
this ->
num);
00092 sql += slask;
00093 }
00094 sql +=
", '" + q.safestr(
this ->
name) +
"'";
00095 sql +=
")";
00096 q.execute(sql);
00097
new_object = 0;
00098 my_ulonglong inserted_id = q.insert_id();
00099
num = inserted_id;
00100
return inserted_id;
00101 }
00102
00103
00104 void Category::update()
00105 {
00106
update(
this ->
num);
00107 }
00108
00109
00110 void Category::update(
long i_num)
00111 {
00112 Query q(*
database);
00113 std::string sql;
00114 {
00115
char slask[200];
00116 sprintf(slask,
"update category set num=%ld",
this ->
num);
00117 sql += slask;
00118 }
00119 sql +=
", name='" + q.safestr(
this ->
name) +
"'";
00120 {
00121
char slask[200];
00122 sprintf(slask,
" where num='%ld'",i_num);
00123 sql += slask;
00124 }
00125 q.execute(sql);
00126 }
00127
00128
00129 void Category::save()
00130 {
00131
if (
new_object)
00132
insert();
00133
else
00134
update();
00135 }
00136
00137
00138 void Category::erase()
00139 {
00140
if (!
new_object)
00141 {
00142 std::string sql =
"delete from category where";
00143 Query q(*
database);
00144 {
00145
char slask[200];
00146 sprintf(slask,
" num='%ld'",
this ->
num);
00147 sql += slask;
00148 }
00149 q.execute(sql);
00150 }
00151 }
00152
00153
00154 std::string Category::xml()
00155 {
00156 Query q(*
database);
00157 std::string dest;
00158
char slask[200];
00159 dest =
"<CATEGORY>";
00160 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00161 dest += slask;
00162 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00163 dest +=
"</CATEGORY>";
00164
return dest;
00165 }
00166
00167
00168 std::string Category::xml(
const std::string& tag,
const std::string& xvalx)
00169 {
00170 Query q(*
database);
00171 std::string dest;
00172
char slask[200];
00173 dest =
"<CATEGORY " + tag +
"=\"" + xvalx +
"\">";
00174 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00175 dest += slask;
00176 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00177 dest +=
"</CATEGORY>";
00178
return dest;
00179 }
00180
00181
00182 size_t Category::num_cols()
00183 {
00184
return 2;
00185 }
00186
00187
00188 void Category::clear()
00189 {
00190
num = 0;
00191
00192 }
00193
00194
00195 void Category::spawn(
const std::string& sql)
00196 {
00197 Query q(*
database);
00198 std::string temp;
00199
00200
clear();
00201
00202
if (!strncasecmp(sql.c_str(),
"select * ",9))
00203 {
00204 temp =
"select num,name " + sql.substr(9);
00205 }
else
00206 temp = sql;
00207 q.get_result(temp);
00208
if (q.fetch_row())
00209 {
00210
num = q.getval(0);
00211
name = q.getstr(1);
00212
new_object = 0;
00213 }
else
00214
clear();
00215 q.free_result();
00216 }
00217
00218
00219 void Category::spawn(Query *qd,
int offset)
00220 {
00221
clear();
00222
00223
num = qd -> getval(0 + offset);
00224
name = qd -> getstr(1 + offset);
00225 }
00226
00227
00228
00229
00230 }
00231
namespace db {
00232
00237 Item::Item(Database *db):typ(mmap_typ)
00238 {
00239
database = db;
00240
new_object = 1;
00241
clear();
00242 }
00243
00244
00245 Item::Item(Database *db,
const std::string& sql):typ(mmap_typ)
00246 {
00247
database = db;
00248
new_object = 1;
00249
spawn(sql);
00250 }
00251
00252
00253 Item::Item(Database *db,Query *qd,
int offset):typ(mmap_typ)
00254 {
00255
database = db;
00256
new_object = 0;
00257
spawn(qd, offset);
00258 }
00259
00260
00261 Item::Item(Database& db,
long i_num):typ(mmap_typ),database(&db),new_object(1)
00262 {
00263 Query q(*
database);
00264 std::string sql =
"select * from item where ";
00265 {
00266
char slask[100];
00267 sprintf(slask,
"num='%ld'",i_num);
00268 sql += slask;
00269 }
00270
spawn(sql);
00271 }
00272
00273
00274 Item::Item(Database& db,
long i_sz,
const std::string& i_sha1):typ(mmap_typ),database(&db),new_object(1)
00275 {
00276 Query q(*
database);
00277 std::string sql =
"select * from item where ";
00278 {
00279
char slask[100];
00280 sprintf(slask,
"sz='%ld'",i_sz);
00281 sql += slask;
00282 }
00283 sql +=
" and sha1='" + q.safestr(i_sha1) +
"'";
00284
spawn(sql);
00285 }
00286
00287
00288 Item::~Item()
00289 {
00290 }
00291
00292
00293 void Item::select(
const std::string& sql)
00294 {
00295
spawn(sql);
00296 }
00297
00298
00299 my_ulonglong Item::insert()
00300 {
00301 Query q(*
database);
00302 std::string sql;
00303
00304 sql =
"insert into item(num,typ,category,name,data,sz,sha1)";
00305 {
00306
char slask[100];
00307 sprintf(slask,
" values(%ld",
this ->
num);
00308 sql += slask;
00309 }
00310 sql +=
", '" + q.safestr(
this ->
typ.String()) +
"'";
00311 {
00312
char slask[100];
00313 sprintf(slask,
", %ld",
this ->
category);
00314 sql += slask;
00315 }
00316 sql +=
", '" + q.safestr(
this ->
name) +
"'";
00317 {
00318 size_t i = 1;
00319 sql +=
", '";
00320
for (std::vector<std::string>::iterator it =
this ->
data.begin(); it !=
this ->
data.end(); it++,i++)
00321 {
00322 sql += q.safestr(*it);
00323
if (i <
this ->
data.size())
00324 sql +=
"\n";
00325 }
00326 sql +=
"'";
00327 }
00328 {
00329
char slask[100];
00330 sprintf(slask,
", %ld",
this ->
sz);
00331 sql += slask;
00332 }
00333 sql +=
", '" + q.safestr(
this ->
sha1) +
"'";
00334 sql +=
")";
00335 q.execute(sql);
00336
new_object = 0;
00337 my_ulonglong inserted_id = q.insert_id();
00338
num = inserted_id;
00339
return inserted_id;
00340 }
00341
00342
00343 void Item::update()
00344 {
00345
update(
this ->
num);
00346 }
00347
00348
00349 void Item::update(
long i_num)
00350 {
00351 Query q(*
database);
00352 std::string sql;
00353 {
00354
char slask[200];
00355 sprintf(slask,
"update item set num=%ld",
this ->
num);
00356 sql += slask;
00357 }
00358 sql +=
", typ='" + q.safestr(
this ->
typ.String()) +
"'";
00359 {
00360
char slask[200];
00361 sprintf(slask,
", category=%ld",
this ->
category);
00362 sql += slask;
00363 }
00364 sql +=
", name='" + q.safestr(
this ->
name) +
"'";
00365 {
00366 size_t i = 1;
00367 sql +=
", data='";
00368
for (std::vector<std::string>::iterator it =
this ->
data.begin(); it !=
this ->
data.end(); it++,i++)
00369 {
00370 sql += q.safestr(*it);
00371
if (i <
this ->
data.size())
00372 sql +=
"\n";
00373 }
00374 sql +=
"'";
00375 }
00376 {
00377
char slask[200];
00378 sprintf(slask,
", sz=%ld",
this ->
sz);
00379 sql += slask;
00380 }
00381 sql +=
", sha1='" + q.safestr(
this ->
sha1) +
"'";
00382 {
00383
char slask[200];
00384 sprintf(slask,
" where num='%ld'",i_num);
00385 sql += slask;
00386 }
00387 q.execute(sql);
00388 }
00389
00390
00391 void Item::save()
00392 {
00393
if (
new_object)
00394
insert();
00395
else
00396
update();
00397 }
00398
00399
00400 void Item::erase()
00401 {
00402
if (!
new_object)
00403 {
00404 std::string sql =
"delete from item where";
00405 Query q(*
database);
00406 {
00407
char slask[200];
00408 sprintf(slask,
" num='%ld'",
this ->
num);
00409 sql += slask;
00410 }
00411 q.execute(sql);
00412 }
00413 }
00414
00415
00416 std::string Item::xml()
00417 {
00418 Query q(*
database);
00419 std::string dest;
00420
char slask[200];
00421 dest =
"<ITEM>";
00422 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00423 dest += slask;
00424 dest +=
"<TYP>" + q.xmlsafestr(
this ->
typ.String()) +
"</TYP>";
00425 sprintf(slask,
"<CATEGORY>%ld</CATEGORY>",
this ->
category);
00426 dest += slask;
00427 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00428 sprintf(slask,
"<SZ>%ld</SZ>",
this ->
sz);
00429 dest += slask;
00430 dest +=
"<SHA1>" + q.xmlsafestr(
this ->
sha1) +
"</SHA1>";
00431 dest +=
"</ITEM>";
00432
return dest;
00433 }
00434
00435
00436 std::string Item::xml(
const std::string& tag,
const std::string& xvalx)
00437 {
00438 Query q(*
database);
00439 std::string dest;
00440
char slask[200];
00441 dest =
"<ITEM " + tag +
"=\"" + xvalx +
"\">";
00442 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00443 dest += slask;
00444 dest +=
"<TYP>" + q.xmlsafestr(
this ->
typ.String()) +
"</TYP>";
00445 sprintf(slask,
"<CATEGORY>%ld</CATEGORY>",
this ->
category);
00446 dest += slask;
00447 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00448 sprintf(slask,
"<SZ>%ld</SZ>",
this ->
sz);
00449 dest += slask;
00450 dest +=
"<SHA1>" + q.xmlsafestr(
this ->
sha1) +
"</SHA1>";
00451 dest +=
"</ITEM>";
00452
return dest;
00453 }
00454
00455
00456 size_t Item::num_cols()
00457 {
00458
return 7;
00459 }
00460
00461
00462 void Item::clear()
00463 {
00464
mmap_typ[
"File"] = 1;
00465
mmap_typ[
"URL"] = 2;
00466
num = 0;
00467
00468
category = 0;
00469
00470
sz = 0;
00471
00472 }
00473
00474
00475 void Item::spawn(
const std::string& sql)
00476 {
00477 Query q(*
database);
00478 std::string temp;
00479
00480
clear();
00481
00482
if (!strncasecmp(sql.c_str(),
"select * ",9))
00483 {
00484 temp =
"select num,typ,category,name,data,sz,sha1 " + sql.substr(9);
00485 }
else
00486 temp = sql;
00487 q.get_result(temp);
00488
if (q.fetch_row())
00489 {
00490
num = q.getval(0);
00491
typ = q.getstr(1);
00492
category = q.getval(2);
00493
name = q.getstr(3);
00494 {
00495 std::string s = q.getstr(4);
00496 std::string tmp;
00497
for (size_t i = 0; i < s.size(); i++)
00498 {
00499
if (s[i] ==
'\n')
00500 {
00501
data.push_back(tmp);
00502 tmp =
"";
00503 }
00504
else
00505 {
00506 tmp += s[i];
00507 }
00508 }
00509
if (tmp.size())
00510
data.push_back(tmp);
00511 }
00512
sz = q.getval(5);
00513
sha1 = q.getstr(6);
00514
new_object = 0;
00515 }
else
00516
clear();
00517 q.free_result();
00518 }
00519
00520
00521 void Item::spawn(Query *qd,
int offset)
00522 {
00523
clear();
00524
00525
num = qd -> getval(0 + offset);
00526
typ = qd -> getstr(1 + offset);
00527
category = qd -> getval(2 + offset);
00528
name = qd -> getstr(3 + offset);
00529 {
00530 std::string s = qd -> getstr(4 + offset);
00531 std::string tmp;
00532
for (size_t i = 0; i < s.size(); i++)
00533 {
00534
if (s[i] ==
'\n')
00535 {
00536
data.push_back(tmp);
00537 tmp =
"";
00538 }
00539
else
00540 {
00541 tmp += s[i];
00542 }
00543 }
00544
if (tmp.size())
00545
data.push_back(tmp);
00546 }
00547
sz = qd -> getval(5 + offset);
00548
sha1 = qd -> getstr(6 + offset);
00549 }
00550
00551
00552
00553
00554 }
00555
namespace db {
00556
00561 Linkitemtag::Linkitemtag(Database *db)
00562 {
00563
database = db;
00564
new_object = 1;
00565
clear();
00566 }
00567
00568
00569 Linkitemtag::Linkitemtag(Database *db,
const std::string& sql)
00570 {
00571
database = db;
00572
new_object = 1;
00573
spawn(sql);
00574 }
00575
00576
00577 Linkitemtag::Linkitemtag(Database *db,Query *qd,
int offset)
00578 {
00579
database = db;
00580
new_object = 0;
00581
spawn(qd, offset);
00582 }
00583
00584
00585 Linkitemtag::Linkitemtag(Database& db,
long i_item,
long i_tag):database(&db),new_object(1)
00586 {
00587 Query q(*
database);
00588 std::string sql =
"select * from linkitemtag where ";
00589 {
00590
char slask[100];
00591 sprintf(slask,
"item='%ld'",i_item);
00592 sql += slask;
00593 }
00594 {
00595
char slask[100];
00596 sprintf(slask,
" and tag='%ld'",i_tag);
00597 sql += slask;
00598 }
00599
spawn(sql);
00600 }
00601
00602
00603 Linkitemtag::~Linkitemtag()
00604 {
00605 }
00606
00607
00608 void Linkitemtag::select(
const std::string& sql)
00609 {
00610
spawn(sql);
00611 }
00612
00613
00614 my_ulonglong Linkitemtag::insert()
00615 {
00616 Query q(*
database);
00617 std::string sql;
00618
00619 sql =
"insert into linkitemtag(item,tag)";
00620 {
00621
char slask[100];
00622 sprintf(slask,
" values(%ld",
this ->
item);
00623 sql += slask;
00624 }
00625 {
00626
char slask[100];
00627 sprintf(slask,
", %ld",
this ->
tag);
00628 sql += slask;
00629 }
00630 sql +=
")";
00631 q.execute(sql);
00632
new_object = 0;
00633 my_ulonglong inserted_id = q.insert_id();
00634
item = inserted_id;
00635
return inserted_id;
00636 }
00637
00638
00639 void Linkitemtag::update()
00640 {
00641
update(
this ->
item,
this ->
tag);
00642 }
00643
00644
00645 void Linkitemtag::update(
long i_item,
long i_tag)
00646 {
00647 Query q(*
database);
00648 std::string sql;
00649 {
00650
char slask[200];
00651 sprintf(slask,
"update linkitemtag set item=%ld",
this ->
item);
00652 sql += slask;
00653 }
00654 {
00655
char slask[200];
00656 sprintf(slask,
", tag=%ld",
this ->
tag);
00657 sql += slask;
00658 }
00659 {
00660
char slask[200];
00661 sprintf(slask,
" where item='%ld'",i_item);
00662 sql += slask;
00663 }
00664 {
00665
char slask[200];
00666 sprintf(slask,
" and tag='%ld'",i_tag);
00667 sql += slask;
00668 }
00669 q.execute(sql);
00670 }
00671
00672
00673 void Linkitemtag::save()
00674 {
00675
if (
new_object)
00676
insert();
00677
else
00678
update();
00679 }
00680
00681
00682 void Linkitemtag::erase()
00683 {
00684
if (!
new_object)
00685 {
00686 std::string sql =
"delete from linkitemtag where";
00687 Query q(*
database);
00688 {
00689
char slask[200];
00690 sprintf(slask,
" item='%ld'",
this ->
item);
00691 sql += slask;
00692 }
00693 {
00694
char slask[200];
00695 sprintf(slask,
" and tag='%ld'",
this ->
tag);
00696 sql += slask;
00697 }
00698 q.execute(sql);
00699 }
00700 }
00701
00702
00703 std::string Linkitemtag::xml()
00704 {
00705 Query q(*
database);
00706 std::string dest;
00707
char slask[200];
00708 dest =
"<LINKITEMTAG>";
00709 sprintf(slask,
"<ITEM>%ld</ITEM>",
this ->
item);
00710 dest += slask;
00711 sprintf(slask,
"<TAG>%ld</TAG>",
this ->
tag);
00712 dest += slask;
00713 dest +=
"</LINKITEMTAG>";
00714
return dest;
00715 }
00716
00717
00718 std::string Linkitemtag::xml(
const std::string& tag,
const std::string& xvalx)
00719 {
00720 Query q(*
database);
00721 std::string dest;
00722
char slask[200];
00723 dest =
"<LINKITEMTAG " + tag +
"=\"" + xvalx +
"\">";
00724 sprintf(slask,
"<ITEM>%ld</ITEM>",
this ->
item);
00725 dest += slask;
00726 sprintf(slask,
"<TAG>%ld</TAG>",
this -> tag);
00727 dest += slask;
00728 dest +=
"</LINKITEMTAG>";
00729
return dest;
00730 }
00731
00732
00733 size_t Linkitemtag::num_cols()
00734 {
00735
return 2;
00736 }
00737
00738
00739 void Linkitemtag::clear()
00740 {
00741
item = 0;
00742
tag = 0;
00743 }
00744
00745
00746 void Linkitemtag::spawn(
const std::string& sql)
00747 {
00748 Query q(*
database);
00749 std::string temp;
00750
00751
clear();
00752
00753
if (!strncasecmp(sql.c_str(),
"select * ",9))
00754 {
00755 temp =
"select item,tag " + sql.substr(9);
00756 }
else
00757 temp = sql;
00758 q.get_result(temp);
00759
if (q.fetch_row())
00760 {
00761
item = q.getval(0);
00762
tag = q.getval(1);
00763
new_object = 0;
00764 }
else
00765
clear();
00766 q.free_result();
00767 }
00768
00769
00770 void Linkitemtag::spawn(Query *qd,
int offset)
00771 {
00772
clear();
00773
00774
item = qd -> getval(0 + offset);
00775
tag = qd -> getval(1 + offset);
00776 }
00777
00778
00779
00780
00781 }
00782
namespace db {
00783
00788 Tag::Tag(Database *db)
00789 {
00790
database = db;
00791
new_object = 1;
00792
clear();
00793 }
00794
00795
00796 Tag::Tag(Database *db,
const std::string& sql)
00797 {
00798
database = db;
00799
new_object = 1;
00800
spawn(sql);
00801 }
00802
00803
00804 Tag::Tag(Database *db,Query *qd,
int offset)
00805 {
00806
database = db;
00807
new_object = 0;
00808
spawn(qd, offset);
00809 }
00810
00811
00812 Tag::Tag(Database& db,
long i_num):database(&db),new_object(1)
00813 {
00814 Query q(*
database);
00815 std::string sql =
"select * from tag where ";
00816 {
00817
char slask[100];
00818 sprintf(slask,
"num='%ld'",i_num);
00819 sql += slask;
00820 }
00821
spawn(sql);
00822 }
00823
00824
00825 Tag::~Tag()
00826 {
00827 }
00828
00829
00830 void Tag::select(
const std::string& sql)
00831 {
00832
spawn(sql);
00833 }
00834
00835
00836 my_ulonglong Tag::insert()
00837 {
00838 Query q(*
database);
00839 std::string sql;
00840
00841 sql =
"insert into tag(num,name)";
00842 {
00843
char slask[100];
00844 sprintf(slask,
" values(%ld",
this ->
num);
00845 sql += slask;
00846 }
00847 sql +=
", '" + q.safestr(
this ->
name) +
"'";
00848 sql +=
")";
00849 q.execute(sql);
00850
new_object = 0;
00851 my_ulonglong inserted_id = q.insert_id();
00852
num = inserted_id;
00853
return inserted_id;
00854 }
00855
00856
00857 void Tag::update()
00858 {
00859
update(
this ->
num);
00860 }
00861
00862
00863 void Tag::update(
long i_num)
00864 {
00865 Query q(*
database);
00866 std::string sql;
00867 {
00868
char slask[200];
00869 sprintf(slask,
"update tag set num=%ld",
this ->
num);
00870 sql += slask;
00871 }
00872 sql +=
", name='" + q.safestr(
this ->
name) +
"'";
00873 {
00874
char slask[200];
00875 sprintf(slask,
" where num='%ld'",i_num);
00876 sql += slask;
00877 }
00878 q.execute(sql);
00879 }
00880
00881
00882 void Tag::save()
00883 {
00884
if (
new_object)
00885
insert();
00886
else
00887
update();
00888 }
00889
00890
00891 void Tag::erase()
00892 {
00893
if (!
new_object)
00894 {
00895 std::string sql =
"delete from tag where";
00896 Query q(*
database);
00897 {
00898
char slask[200];
00899 sprintf(slask,
" num='%ld'",
this ->
num);
00900 sql += slask;
00901 }
00902 q.execute(sql);
00903 }
00904 }
00905
00906
00907 std::string Tag::xml()
00908 {
00909 Query q(*
database);
00910 std::string dest;
00911
char slask[200];
00912 dest =
"<TAG>";
00913 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00914 dest += slask;
00915 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00916 dest +=
"</TAG>";
00917
return dest;
00918 }
00919
00920
00921 std::string Tag::xml(
const std::string& tag,
const std::string& xvalx)
00922 {
00923 Query q(*
database);
00924 std::string dest;
00925
char slask[200];
00926 dest =
"<TAG " + tag +
"=\"" + xvalx +
"\">";
00927 sprintf(slask,
"<NUM>%ld</NUM>",
this ->
num);
00928 dest += slask;
00929 dest +=
"<NAME>" + q.xmlsafestr(
this ->
name) +
"</NAME>";
00930 dest +=
"</TAG>";
00931
return dest;
00932 }
00933
00934
00935 size_t Tag::num_cols()
00936 {
00937
return 2;
00938 }
00939
00940
00941 void Tag::clear()
00942 {
00943
num = 0;
00944
00945 }
00946
00947
00948 void Tag::spawn(
const std::string& sql)
00949 {
00950 Query q(*
database);
00951 std::string temp;
00952
00953
clear();
00954
00955
if (!strncasecmp(sql.c_str(),
"select * ",9))
00956 {
00957 temp =
"select num,name " + sql.substr(9);
00958 }
else
00959 temp = sql;
00960 q.get_result(temp);
00961
if (q.fetch_row())
00962 {
00963
num = q.getval(0);
00964
name = q.getstr(1);
00965
new_object = 0;
00966 }
else
00967
clear();
00968 q.free_result();
00969 }
00970
00971
00972 void Tag::spawn(Query *qd,
int offset)
00973 {
00974
clear();
00975
00976
num = qd -> getval(0 + offset);
00977
name = qd -> getstr(1 + offset);
00978 }
00979
00980
00981
00982
00983 }