zypp/cache/ResolvableQuery.cc

   1
   2 #include "zypp/cache/CacheTypes.h"
   3 #include "zypp/cache/ResolvableQuery.h"
   4 #include "zypp/Package.h"
   5 #include "zypp/cache/sqlite3x/sqlite3x.hpp"
   6
   7 using namespace sqlite3x;
   8 using namespace std;
   9
  10 namespace zypp { namespace cache {
  11
  12
  13 struct ResolvableQuery::Impl
  14 {
  15   Pathname _dbdir;
  16   string _fields;
  17   CacheTypes _type_cache;
  18
  19   Impl( const Pathname &dbdir)
  20   : _dbdir(dbdir)
  21     , _type_cache(dbdir)
  22   {
  23     _fields = "id, name, version, release, epoch, arch, kind, installed_size, archive_size, install_only, build_time, install_time, repository_id";
  24   }
  25
  26   ~Impl()
  27   {
  28   }
  29
  30   data::ResObject_Ptr fromRow( sqlite3_reader &reader )
  31   {
  32     data::ResObject_Ptr ptr (new data::ResObject);
  33
  34     ptr->name = reader.getstring(1);
  35     ptr->edition = Edition( reader.getstring(2), reader.getstring(3), reader.getint(4));
  36     ptr->arch = _type_cache.archFor(reader.getint(5));
  37
  38     // TODO get the rest of the data
  39
  40     return ptr;
  41   }
  42
  43
  44   void query( const data::RecordId &id,
  45                   ProcessResolvable fnc )
  46   {
  47     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
  48     //con.executenonquery("PRAGMA cache_size=8000;");
  49     con.executenonquery("BEGIN;");
  50     sqlite3_command cmd( con, "select " + _fields + " from resolvables where id=:id;");
  51     cmd.bind(":id", id);
  52     sqlite3_reader reader = cmd.executereader();
  53     while(reader.read())
  54     {
  55       fnc( id, fromRow(reader) );
  56     }
  57     con.executenonquery("COMMIT;");
  58   }
  59
  60
  61   void query( const std::string &s,
  62               ProcessResolvable fnc  )
  63   {
  64
  65     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
  66     //con.executenonquery("PRAGMA cache_size=8000;");
  67     con.executenonquery("BEGIN;");
  68     sqlite3_command cmd( con, "select " + _fields + " from resolvables where name like '%:name%';");
  69     cmd.bind(":name", s);
  70     sqlite3_reader reader = cmd.executereader();
  71     while(reader.read())
  72     {
  73       fnc( reader.getint64(0), fromRow(reader) );
  74     }
  75     con.executenonquery("COMMIT;");
  76   }
  77
  78
  79   std::string queryStringAttribute( const data::RecordId &record_id,
  80                                     const std::string &klass,
  81                                     const std::string &name )
  82   {
  83     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
  84     return queryStringAttributeTranslationInternal( con, record_id, Locale(), klass, name);
  85   }
  86
  87
  88   std::string queryStringAttributeTranslation( const data::RecordId &record_id,
  89                                                const Locale &locale,
  90                                                const std::string &klass,
  91                                                const std::string &name )
  92   {
  93     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
  94     return queryStringAttributeTranslationInternal( con, record_id, locale, klass, name );
  95   }
  96
  97
  98   TranslatedText queryTranslatedStringAttribute( const data::RecordId &record_id,
  99                                                  const std::string &klass,
 100                                                  const std::string &name )
 101   {
 102     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
 103     return queryTranslatedStringAttributeInternal( con, record_id, klass, name );
 104   }
 105
 106
 107   bool queryBooleanAttribute( const data::RecordId &record_id,
 108                                         const std::string &klass,
 109                                         const std::string &name )
 110   {
 111     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
 112     return ( queryNumericAttributeInternal( con, record_id, klass, name) != 0 );
 113   }
 114
 115   template <class _Container> _Container
 116   queryStringContainerAttribute( const data::RecordId &record_id,
 117                                  const std::string &klass,
 118                                  const std::string &name )
 119   {
 120     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
 121     string all = queryStringAttributeInternal( con, record_id, klass, name);
 122     _Container words;
 123
 124     //
 125     //str::split( all, std::inserter(words) );
 126     return words;
 127   }
 128
 129
 130   int queryNumericAttribute( const data::RecordId &record_id,
 131                                  const std::string &klass,
 132                                  const std::string &name )
 133   {
 134     sqlite3_connection con((_dbdir + "zypp.db").asString().c_str());
 135     return queryNumericAttributeInternal( con, record_id, klass, name);
 136   }
 137
 138 private:
 139
 140   int queryNumericAttributeInternal( sqlite3_connection &con,
 141                                      const data::RecordId &record_id,
 142                                      const std::string &klass,
 143                                      const std::string &name )
 144   {
 145     con.executenonquery("BEGIN;");
 146     sqlite3_command cmd( con, "select a.value from numeric_attributes a,types t where a.weak_resolvable_id=:rid and a.attr_id=t.id and t.class=:tclass and t.name=:tname;");
 147
 148     cmd.bind(":rid", record_id);
 149
 150     cmd.bind(":tclass", klass);
 151     cmd.bind(":tname", name);
 152
 153     return cmd.executeint();
 154   }
 155
 156   TranslatedText queryTranslatedStringAttributeInternal( sqlite3_connection &con,
 157                                                          const data::RecordId &record_id,
 158                                                          const std::string &klass,
 159                                                          const std::string &name )
 160   {
 161     //con.executenonquery("PRAGMA cache_size=8000;");
 162     con.executenonquery("BEGIN;");
 163     sqlite3_command cmd( con, "select a.text, l.name from text_attributes a,types l,types t where a.weak_resolvable_id=:rid and a.lang_id=l.id and a.attr_id=t.id and l.class=:lclass and t.class=:tclass and t.name=:tname;");
 164
 165     cmd.bind(":rid", record_id);
 166     cmd.bind(":lclass", "lang");
 167
 168     cmd.bind(":tclass", klass);
 169     cmd.bind(":tname", name);
 170
 171     TranslatedText result;
 172     sqlite3_reader reader = cmd.executereader();
 173     while(reader.read())
 174     {
 175       result.setText( reader.getstring(0), Locale( reader.getstring(1) ) );
 176     }
 177     return result;
 178   }
 179
 180   std::string queryStringAttributeInternal( sqlite3_connection &con,
 181                                             const data::RecordId &record_id,
 182                                             const std::string &klass,
 183                                             const std::string &name )
 184   {
 185     return queryStringAttributeTranslationInternal( con, record_id, Locale(), klass, name);
 186   }
 187
 188   std::string queryStringAttributeTranslationInternal( sqlite3_connection &con,
 189                                                        const data::RecordId &record_id,
 190                                                        const Locale &locale,
 191                                                        const std::string &klass,
 192                                                        const std::string &name )
 193   {
 194     //con.executenonquery("PRAGMA cache_size=8000;");
 195     con.executenonquery("BEGIN;");
 196     sqlite3_command cmd( con, "select a.text from text_attributes a,types l,types t where a.weak_resolvable_id=:rid and a.lang_id=l.id and a.attr_id=t.id and l.class=:lclass and l.name=:lname and t.class=:tclass and t.name=:tname;");
 197
 198     cmd.bind(":rid", record_id);
 199     cmd.bind(":lclass", "lang");
 200     if (locale == Locale() )
 201       cmd.bind(":lname", "none");
 202     else
 203       cmd.bind(":lname", locale.code());
 204
 205     cmd.bind(":tclass", klass);
 206     cmd.bind(":tname", name);
 207
 208     return cmd.executestring();
 209   }
 210 };
 211
 212 template
 213 list<string> ResolvableQuery::Impl::queryStringContainerAttribute( const data::RecordId &record_id,
 214                                                                    const std::string &klass,
 215                                                                    const std::string &name );
 216
 217 template
 218 set<string> ResolvableQuery::Impl::queryStringContainerAttribute( const data::RecordId &record_id,
 219                                                                   const std::string &klass,
 220                                                                   const std::string &name );
 221
 222 //////////////////////////////////////////////////////////////////////////////
 223 // FORWARD TO IMPLEMENTATION
 224 //////////////////////////////////////////////////////////////////////////////
 225
 226 ResolvableQuery::ResolvableQuery( const Pathname &dbdir)
 227   : _pimpl(new Impl(dbdir))
 228 {
 229 }
 230
 231 //////////////////////////////////////////////////////////////////////////////
 232
 233 void ResolvableQuery::query( const data::RecordId &id, ProcessResolvable fnc  )
 234 {
 235   _pimpl->query(id, fnc);
 236 }
 237
 238 //////////////////////////////////////////////////////////////////////////////
 239
 240 void ResolvableQuery::query( const std::string &s, ProcessResolvable fnc  )
 241 {
 242   _pimpl->query(s, fnc);
 243 }
 244
 245 //////////////////////////////////////////////////////////////////////////////
 246
 247 int ResolvableQuery::queryNumericAttribute( const data::RecordId &record_id,
 248                                             const std::string &klass,
 249                                             const std::string &name )
 250 {
 251   return _pimpl->queryNumericAttribute(record_id, klass, name);
 252 }
 253
 254 bool ResolvableQuery::queryBooleanAttribute( const data::RecordId &record_id,
 255                                              const std::string &klass,
 256                                              const std::string &name )
 257 {
 258   return _pimpl->queryNumericAttribute(record_id, klass, name);
 259 }
 260
 261
 262 std::string ResolvableQuery::queryStringAttribute( const data::RecordId &record_id,
 263                                                    const std::string &klass,
 264                                                    const std::string &name )
 265 {
 266   return _pimpl->queryStringAttribute(record_id, klass, name);
 267 }
 268
 269 //////////////////////////////////////////////////////////////////////////////
 270
 271 std::string ResolvableQuery::queryStringAttributeTranslation( const data::RecordId &record_id,
 272                                                               const Locale &locale,
 273                                                               const std::string &klass,
 274                                                               const std::string &name )
 275 {
 276   return _pimpl->queryStringAttributeTranslation(record_id, locale, klass, name);
 277 }
 278
 279 //////////////////////////////////////////////////////////////////////////////
 280
 281 TranslatedText ResolvableQuery::queryTranslatedStringAttribute( const data::RecordId &record_id,
 282                                                                 const std::string &klass,
 283                                                                 const std::string &name )
 284 {
 285   return _pimpl->queryTranslatedStringAttribute(record_id, klass, name);
 286 }
 287
 288 template<class _Container>
 289 _Container ResolvableQuery::queryStringContainerAttribute( const data::RecordId &record_id,
 290                                                            const std::string &klass,
 291                                                            const std::string &name )
 292 {
 293   return _pimpl->queryStringContainerAttribute<_Container>(record_id, klass, name);
 294 }
 295
 296 template
 297 std::set<std::string> ResolvableQuery::queryStringContainerAttribute( const data::RecordId &record_id,
 298                                                                       const std::string &klass,
 299                                                                       const std::string &name );
 300
 301 template
 302 std::list<std::string> ResolvableQuery::queryStringContainerAttribute( const data::RecordId &record_id,
 303                                                                        const std::string &klass,
 304                                                                        const std::string &name );
 305
 306 template
 307 Package::Keywords ResolvableQuery::queryStringContainerAttribute( const data::RecordId &record_id,
 308                                                                   const std::string &klass,
 309                                                                   const std::string &name );
 310
 311 //////////////////////////////////////////////////////////////////////////////
 312
 313 } } // namespace zypp::cache