libdb/libdb.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  * $Id: libdb.c,v 1.10 2005/03/05 21:39:44 nedko Exp $
   5  *
   6  * DESCRIPTION:
   7  *  Unified access to database.
   8  *
   9  * AUTHOR:
  10  *  Nedko Arnaudov <nedko@users.sourceforge.net>
  11  *
  12  * LICENSE:
  13  *  GNU GENERAL PUBLIC LICENSE version 2
  14  *
  15  *****************************************************************************/
  16
  17 #include <stdlib.h>
  18 #include <assert.h>
  19 #include <string.h>
  20
  21 #include "../result.h"
  22 #include "internal.h"
  23 #include "memory.h"
  24
  25 char *pszErrorMsg = NULL;
  26
  27 mediadb_result
  28 mediadb_open(
  29   unsigned int nDBType,
  30   const char *pszHost,
  31   const char *pszUser,
  32   const char *pszPass,
  33   const char *pszDB,
  34   mediadb *phDB)
  35 {
  36   mediadb_result r;
  37   mediadb_impl *pImpl;
  38
  39   pImpl = malloc(sizeof(mediadb_impl));
  40   if (pImpl == NULL)
  41   {
  42     r = MEDIADB_MEM;
  43     goto Fail;
  44   }
  45
  46   pImpl->nDBType = nDBType;
  47
  48   if (nDBType == MEDIADB_DBTYPE_MYSQL)
  49   {
  50     r = mediadb_mysql_open(
  51       &pImpl->data.mysql,
  52       pszHost,
  53       pszUser,
  54       pszPass,
  55       pszDB);
  56     if (MEDIADB_IS_ERROR(r))
  57     {
  58       if (pszErrorMsg != NULL)
  59         free(pszErrorMsg);
  60       pszErrorMsg = strdup(mediadb_mysql_get_error_message(&pImpl->data.mysql));
  61       goto FailFreeMem;
  62     }
  63   }
  64   else if (nDBType == MEDIADB_DBTYPE_SQLITE)
  65   {
  66     r = mediadb_sqlite_open(
  67       &pImpl->data.sqlite,
  68       pszHost,
  69       pszUser,
  70       pszPass,
  71       pszDB);
  72     if (MEDIADB_IS_ERROR(r))
  73     {
  74       if (pszErrorMsg != NULL)
  75         free(pszErrorMsg);
  76       pszErrorMsg = strdup(mediadb_sqlite_get_error_message(&pImpl->data.sqlite));
  77       goto FailFreeMem;
  78     }
  79   }
  80   else
  81   {
  82     r = MEDIADB_NOT_IMPL;
  83     goto FailFreeMem;
  84   }
  85
  86   *phDB = (mediadb)pImpl;
  87
  88   return MEDIADB_OK;
  89
  90 FailFreeMem:
  91   free(pImpl);
  92 Fail:
  93   return r;
  94 }
  95
  96 #define pDB ((mediadb_impl *)hDB)
  97
  98 mediadb_result
  99 mediadb_media_add_new(
 100   mediadb hDB,
 101   const char *pszName,
 102   const char *pszComment,
 103   mediadb_mediatype nType,
 104   mediadb_uint *pnNewMediaID)
 105 {
 106   mediadb_result r;
 107
 108   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 109   {
 110     r = mediadb_mysql_media_add_new(
 111       &pDB->data.mysql,
 112       pszName,
 113       pszComment,
 114       nType,
 115       pnNewMediaID);
 116   }
 117   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 118   {
 119     r = mediadb_sqlite_media_add_new(
 120       &pDB->data.sqlite,
 121       pszName,
 122       pszComment,
 123       nType,
 124       pnNewMediaID);
 125   }
 126   else
 127   {
 128     r = MEDIADB_INVAL_ARG;
 129     assert(0);
 130   }
 131
 132   return r;
 133 }
 134
 135 mediadb_result
 136 mediadb_media_update_properties(
 137   mediadb hDB,
 138   mediadb_uint nMediaID,
 139   mediadb_uint nTimeAdded,
 140   mediadb_uint nTotalFiles,
 141   mediadb_uint nTotalSize)
 142 {
 143   mediadb_result r;
 144
 145   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 146   {
 147     r = mediadb_mysql_media_update_properties(
 148       &pDB->data.mysql,
 149       nMediaID,
 150       nTimeAdded,
 151       nTotalFiles,
 152       nTotalSize);
 153   }
 154   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 155   {
 156     r = mediadb_sqlite_media_update_properties(
 157       &pDB->data.sqlite,
 158       nMediaID,
 159       nTimeAdded,
 160       nTotalFiles,
 161       nTotalSize);
 162   }
 163   else
 164   {
 165     r = MEDIADB_INVAL_ARG;
 166     assert(0);
 167   }
 168
 169   return r;
 170 }
 171
 172 mediadb_result
 173 mediadb_file_add_new(
 174   mediadb hDB,
 175   mediadb_uint nMediaID,
 176   mediadb_filetype Filetype,
 177   const char *pszPath,
 178   const char *pszName,
 179   mediadb_uint nFileSize,
 180   mediadb_uint nFileTime)
 181 {
 182   mediadb_result r;
 183
 184   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 185   {
 186     r = mediadb_mysql_file_add_new(
 187       &pDB->data.mysql,
 188       nMediaID,
 189       Filetype,
 190       pszPath,
 191       pszName,
 192       nFileSize,
 193       nFileTime);
 194   }
 195   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 196   {
 197     r = mediadb_sqlite_file_add_new(
 198       &pDB->data.sqlite,
 199       nMediaID,
 200       Filetype,
 201       pszPath,
 202       pszName,
 203       nFileSize,
 204       nFileTime);
 205   }
 206   else
 207   {
 208     r = MEDIADB_INVAL_ARG;
 209     assert(0);
 210   }
 211
 212   return r;
 213 }
 214
 215 mediadb_result
 216 mediadb_media_get_properties(
 217   mediadb hDB,
 218   mediadb_uint nMediaID,
 219   mediadb_uint *pnTimeAdded,
 220   mediadb_mediatype *pnType,
 221   mediadb_uint *pnLocationID,
 222   char **ppszTitle)
 223 {
 224   mediadb_result r;
 225
 226   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 227   {
 228     r = mediadb_mysql_media_get_properties(
 229       &pDB->data.mysql,
 230       nMediaID,
 231       pnTimeAdded,
 232       pnType,
 233       pnLocationID,
 234       ppszTitle);
 235   }
 236   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 237   {
 238     r = mediadb_sqlite_media_get_properties(
 239       &pDB->data.sqlite,
 240       nMediaID,
 241       pnTimeAdded,
 242       pnType,
 243       pnLocationID,
 244       ppszTitle);
 245   }
 246   else
 247   {
 248     r = MEDIADB_INVAL_ARG;
 249     assert(0);
 250   }
 251
 252   return r;
 253 }
 254
 255 mediadb_result
 256 mediadb_location_get_properties(
 257   mediadb hDB,
 258   mediadb_uint nLocationID,
 259   mediadb_uint *pnLocationTypeID,
 260   char **ppszDescription)
 261 {
 262   mediadb_result r;
 263
 264   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 265   {
 266     r = mediadb_mysql_location_get_properties(
 267       &pDB->data.mysql,
 268       nLocationID,
 269       pnLocationTypeID,
 270       ppszDescription);
 271   }
 272   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 273   {
 274     r = mediadb_sqlite_location_get_properties(
 275       &pDB->data.sqlite,
 276       nLocationID,
 277       pnLocationTypeID,
 278       ppszDescription);
 279   }
 280   else
 281   {
 282     r = MEDIADB_INVAL_ARG;
 283     assert(0);
 284   }
 285
 286   return r;
 287 }
 288
 289 mediadb_result
 290 mediadb_location_type_get_properties(
 291   mediadb hDB,
 292   mediadb_uint nLocationTypeID,
 293   char **ppszDescription)
 294 {
 295   mediadb_result r;
 296
 297   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 298   {
 299     r = mediadb_mysql_location_type_get_properties(
 300       &pDB->data.mysql,
 301       nLocationTypeID,
 302       ppszDescription);
 303   }
 304   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 305   {
 306     r = mediadb_sqlite_location_type_get_properties(
 307       &pDB->data.sqlite,
 308       nLocationTypeID,
 309       ppszDescription);
 310   }
 311   else
 312   {
 313     r = MEDIADB_INVAL_ARG;
 314     assert(0);
 315   }
 316
 317   return r;
 318 }
 319
 320 mediadb_result
 321 mediadb_media_get_properties_data(
 322   mediadb hDB,
 323   mediadb_uint nMediaID,
 324   mediadb_uint *pnTotalFiles,
 325   mediadb_uint *pnTotalSize)
 326 {
 327   mediadb_result r;
 328
 329   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 330   {
 331     r = mediadb_mysql_media_get_properties_data(
 332       &pDB->data.mysql,
 333       nMediaID,
 334       pnTotalFiles,
 335       pnTotalSize);
 336   }
 337   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 338   {
 339     r = mediadb_sqlite_media_get_properties_data(
 340       &pDB->data.sqlite,
 341       nMediaID,
 342       pnTotalFiles,
 343       pnTotalSize);
 344   }
 345   else
 346   {
 347     r = MEDIADB_INVAL_ARG;
 348     assert(0);
 349   }
 350
 351   return r;
 352 }
 353
 354 mediadb_result
 355 mediadb_delete_media_files(
 356   mediadb hDB,
 357   mediadb_uint nMediaID)
 358 {
 359   mediadb_result r;
 360
 361   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 362   {
 363     r = mediadb_mysql_delete_media_files(
 364       &pDB->data.mysql,
 365       nMediaID);
 366   }
 367   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 368   {
 369     r = mediadb_sqlite_delete_media_files(
 370       &pDB->data.sqlite,
 371       nMediaID);
 372   }
 373   else
 374   {
 375     r = MEDIADB_INVAL_ARG;
 376     assert(0);
 377   }
 378
 379   return r;
 380 }
 381
 382 mediadb_result
 383 mediadb_media_update_name(
 384   mediadb hDB,
 385   mediadb_uint nMediaID,
 386   const char *pszName)
 387 {
 388   mediadb_result r;
 389
 390   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 391   {
 392     r = mediadb_mysql_media_update_name(
 393       &pDB->data.mysql,
 394       nMediaID,
 395       pszName);
 396   }
 397   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 398   {
 399     r = mediadb_sqlite_media_update_name(
 400       &pDB->data.sqlite,
 401       nMediaID,
 402       pszName);
 403   }
 404   else
 405   {
 406     r = MEDIADB_INVAL_ARG;
 407     assert(0);
 408   }
 409
 410   return r;
 411 }
 412
 413 mediadb_result
 414 mediadb_close(
 415   mediadb hDB)
 416 {
 417   mediadb_result r;
 418
 419   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 420   {
 421     r = mediadb_mysql_close(
 422       &pDB->data.mysql);
 423   }
 424   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 425   {
 426     r = mediadb_sqlite_close(
 427       &pDB->data.sqlite);
 428   }
 429   else
 430   {
 431     r = MEDIADB_INVAL_ARG;
 432     assert(0);
 433   }
 434
 435   if (MEDIADB_IS_ERROR(r))
 436   {
 437     return r;
 438   }
 439
 440   free(pDB);
 441
 442   return r;
 443 }
 444
 445 const char *
 446 mediadb_get_error_message(
 447   mediadb hDB)
 448 {
 449   if (pDB == NULL)
 450   {
 451     if (pszErrorMsg == NULL)
 452     {
 453       return "";
 454     }
 455     else
 456     {
 457       return pszErrorMsg;
 458     }
 459   }
 460
 461   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 462   {
 463     return mediadb_mysql_get_error_message(&pDB->data.mysql);
 464   }
 465
 466   if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 467   {
 468     return mediadb_sqlite_get_error_message(&pDB->data.sqlite);
 469   }
 470
 471   assert(0);
 472   return "enexpected behaviour";
 473 }
 474
 475 mediadb_result
 476 mediadb_media_get_all(
 477   mediadb hDB,
 478   mediadb_media_callback pCallback,
 479   void *pUserContext)
 480 {
 481   mediadb_result r;
 482
 483   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 484   {
 485     r = mediadb_mysql_media_get_all(
 486       &pDB->data.mysql,
 487       pCallback,
 488       pUserContext);
 489   }
 490   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 491   {
 492     r = mediadb_sqlite_media_get_all(
 493       &pDB->data.sqlite,
 494       pCallback,
 495       pUserContext);
 496   }
 497   else
 498   {
 499     r = MEDIADB_INVAL_ARG;
 500     assert(0);
 501   }
 502
 503   return r;
 504 }
 505
 506 mediadb_result
 507 mediadb_files_get(
 508   mediadb hDB,
 509   mediadb_uint nMediaID,
 510   const char *pszPath,
 511   mediadb_files_callback pCallback,
 512   void *pUserContext)
 513 {
 514   mediadb_result r;
 515
 516   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 517   {
 518     r = mediadb_mysql_files_get(
 519       &pDB->data.mysql,
 520       nMediaID,
 521       pszPath,
 522       pCallback,
 523       pUserContext);
 524   }
 525   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 526   {
 527     r = mediadb_sqlite_files_get(
 528       &pDB->data.sqlite,
 529       nMediaID,
 530       pszPath,
 531       pCallback,
 532       pUserContext);
 533   }
 534   else
 535   {
 536     r = MEDIADB_INVAL_ARG;
 537     assert(0);
 538   }
 539
 540   return r;
 541 }
 542
 543 mediadb_result
 544 mediadb_get_pattern_match_methods(
 545   mediadb hDB,
 546   const struct mediadb_pattern_match_method **ppPMM)
 547 {
 548   mediadb_result r;
 549
 550   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 551   {
 552     r = mediadb_mysql_get_pattern_match_methods(
 553       &pDB->data.mysql,
 554       ppPMM);
 555   }
 556   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 557   {
 558     r = mediadb_sqlite_get_pattern_match_methods(
 559       &pDB->data.sqlite,
 560       ppPMM);
 561   }
 562   else
 563   {
 564     r = MEDIADB_INVAL_ARG;
 565     assert(0);
 566   }
 567
 568   return r;
 569 }
 570
 571 mediadb_result
 572 mediadb_files_search(
 573   mediadb hDB,
 574   mediadb_uint nFilenamePMMID,
 575   const char *pszFilenamePattern,
 576   mediadb_uint nPathPMMID,
 577   const char *pszPathPattern,
 578   const mediadb_uint *pnMinSize,
 579   const mediadb_uint *pnMaxSize,
 580   mediadb_files_search_callback pCallback,
 581   void *pUserContext)
 582 {
 583   mediadb_result r;
 584
 585   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 586   {
 587     r = mediadb_mysql_files_search(
 588       &pDB->data.mysql,
 589       nFilenamePMMID,
 590       pszFilenamePattern,
 591       nPathPMMID,
 592       pszPathPattern,
 593       pnMinSize,
 594       pnMaxSize,
 595       pCallback,
 596       pUserContext);
 597   }
 598   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 599   {
 600     r = mediadb_sqlite_files_search(
 601       &pDB->data.sqlite,
 602       nFilenamePMMID,
 603       pszFilenamePattern,
 604       nPathPMMID,
 605       pszPathPattern,
 606       pnMinSize,
 607       pnMaxSize,
 608       pCallback,
 609       pUserContext);
 610   }
 611   else
 612   {
 613     r = MEDIADB_INVAL_ARG;
 614     assert(0);
 615   }
 616
 617   return r;
 618 }
 619
 620 mediadb_result
 621 mediadb_file_get_properties(
 622   mediadb hDB,
 623   mediadb_uint nMediaID,
 624   const char *pszPath,
 625   const char *pszName,
 626   mediadb_filetype *pFiletype,
 627   mediadb_uint *pnSize,
 628   mediadb_uint *pnTime)
 629 {
 630   mediadb_result r;
 631
 632   if (pDB->nDBType == MEDIADB_DBTYPE_MYSQL)
 633   {
 634     r = mediadb_mysql_file_get_properties(
 635       &pDB->data.mysql,
 636       nMediaID,
 637       pszPath,
 638       pszName,
 639       pFiletype,
 640       pnSize,
 641       pnTime);
 642   }
 643   else if (pDB->nDBType == MEDIADB_DBTYPE_SQLITE)
 644   {
 645     r = mediadb_sqlite_file_get_properties(
 646       &pDB->data.sqlite,
 647       nMediaID,
 648       pszPath,
 649       pszName,
 650       pFiletype,
 651       pnSize,
 652       pnTime);
 653   }
 654   else
 655   {
 656     r = MEDIADB_INVAL_ARG;
 657     assert(0);
 658   }
 659
 660   return r;
 661 }
 662
 663 /*****************************************************************************
 664  *
 665  * Modifications log:
 666  *
 667  * !!! WARNING !!! Following lines are automatically updated by the CVS system.
 668  *
 669  *   $Log: libdb.c,v $
 670  *   Revision 1.10  2005/03/05 21:39:44  nedko
 671  *   new functionality - file_get_properties()
 672  *
 673  *   Revision 1.9  2004/08/31 22:40:15  nedko
 674  *   Partitally implemented search feature.
 675  *
 676  *   Revision 1.8  2004/08/08 00:47:42  nedko
 677  *   Get more info for media from database.
 678  *
 679  *   Revision 1.7  2004/05/21 23:40:46  nedko
 680  *   New functionality: mediadb_files_get()
 681  *
 682  *   Revision 1.6  2004/05/16 18:57:12  nedko
 683  *   media_get_all functionality implemented.
 684  *
 685  *   Revision 1.5  2004/05/11 01:17:42  nedko
 686  *   Allow mediadb_get_error_message() to work after failed database open.
 687  *
 688  *   Revision 1.4  2004/05/03 20:47:14  nedko
 689  *   Update mode for cui
 690  *
 691  *   Revision 1.3  2004/05/02 20:12:11  nedko
 692  *   Improve error dumps.
 693  *
 694  *   Revision 1.2  2004/05/02 13:16:58  nedko
 695  *   Supply filetype when adding new file
 696  *
 697  *   Revision 1.1  2004/04/27 09:12:28  nedko
 698  *   Initial revision.
 699  *
 700  *****************************************************************************/