Home | History | Annotate | Download | only in database 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "storage/browser/database/databases_table.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "sql/statement.h"
     10 
     11 namespace storage {
     12 
     13 DatabaseDetails::DatabaseDetails() : estimated_size(0) { }
     14 
     15 DatabaseDetails::~DatabaseDetails() {}
     16 
     17 bool DatabasesTable::Init() {
     18   // 'Databases' schema:
     19   //   id              A unique ID assigned to each database
     20   //   origin          The originto which the database belongs. This is a
     21   //                   string that can be used as part of a file name
     22   //                   (http_webkit.org_0, for example).
     23   //   name            The database name.
     24   //   description     A short description of the database.
     25   //   estimated_size  The estimated size of the database.
     26   return db_->DoesTableExist("Databases") ||
     27       (db_->Execute(
     28            "CREATE TABLE Databases ("
     29            "id INTEGER PRIMARY KEY AUTOINCREMENT, "
     30            "origin TEXT NOT NULL, "
     31            "name TEXT NOT NULL, "
     32            "description TEXT NOT NULL, "
     33            "estimated_size INTEGER NOT NULL)") &&
     34        db_->Execute(
     35            "CREATE INDEX origin_index ON Databases (origin)") &&
     36        db_->Execute(
     37            "CREATE UNIQUE INDEX unique_index ON Databases (origin, name)"));
     38 }
     39 
     40 int64 DatabasesTable::GetDatabaseID(const std::string& origin_identifier,
     41                                     const base::string16& database_name) {
     42   sql::Statement select_statement(db_->GetCachedStatement(
     43       SQL_FROM_HERE, "SELECT id FROM Databases WHERE origin = ? AND name = ?"));
     44   select_statement.BindString(0, origin_identifier);
     45   select_statement.BindString16(1, database_name);
     46 
     47   if (select_statement.Step()) {
     48     return select_statement.ColumnInt64(0);
     49   }
     50 
     51   return -1;
     52 }
     53 
     54 bool DatabasesTable::GetDatabaseDetails(const std::string& origin_identifier,
     55                                         const base::string16& database_name,
     56                                         DatabaseDetails* details) {
     57   DCHECK(details);
     58   sql::Statement select_statement(db_->GetCachedStatement(
     59       SQL_FROM_HERE, "SELECT description, estimated_size FROM Databases "
     60                      "WHERE origin = ? AND name = ?"));
     61   select_statement.BindString(0, origin_identifier);
     62   select_statement.BindString16(1, database_name);
     63 
     64   if (select_statement.Step()) {
     65     details->origin_identifier = origin_identifier;
     66     details->database_name = database_name;
     67     details->description = select_statement.ColumnString16(0);
     68     details->estimated_size = select_statement.ColumnInt64(1);
     69     return true;
     70   }
     71 
     72   return false;
     73 }
     74 
     75 bool DatabasesTable::InsertDatabaseDetails(const DatabaseDetails& details) {
     76   sql::Statement insert_statement(db_->GetCachedStatement(
     77       SQL_FROM_HERE, "INSERT INTO Databases (origin, name, description, "
     78                      "estimated_size) VALUES (?, ?, ?, ?)"));
     79   insert_statement.BindString(0, details.origin_identifier);
     80   insert_statement.BindString16(1, details.database_name);
     81   insert_statement.BindString16(2, details.description);
     82   insert_statement.BindInt64(3, details.estimated_size);
     83 
     84   return insert_statement.Run();
     85 }
     86 
     87 bool DatabasesTable::UpdateDatabaseDetails(const DatabaseDetails& details) {
     88   sql::Statement update_statement(db_->GetCachedStatement(
     89       SQL_FROM_HERE, "UPDATE Databases SET description = ?, "
     90                      "estimated_size = ? WHERE origin = ? AND name = ?"));
     91   update_statement.BindString16(0, details.description);
     92   update_statement.BindInt64(1, details.estimated_size);
     93   update_statement.BindString(2, details.origin_identifier);
     94   update_statement.BindString16(3, details.database_name);
     95 
     96   return (update_statement.Run() && db_->GetLastChangeCount());
     97 }
     98 
     99 bool DatabasesTable::DeleteDatabaseDetails(
    100     const std::string& origin_identifier,
    101     const base::string16& database_name) {
    102   sql::Statement delete_statement(db_->GetCachedStatement(
    103       SQL_FROM_HERE, "DELETE FROM Databases WHERE origin = ? AND name = ?"));
    104   delete_statement.BindString(0, origin_identifier);
    105   delete_statement.BindString16(1, database_name);
    106 
    107   return (delete_statement.Run() && db_->GetLastChangeCount());
    108 }
    109 
    110 bool DatabasesTable::GetAllOriginIdentifiers(
    111     std::vector<std::string>* origin_identifiers) {
    112   sql::Statement statement(db_->GetCachedStatement(
    113       SQL_FROM_HERE, "SELECT DISTINCT origin FROM Databases ORDER BY origin"));
    114 
    115   while (statement.Step())
    116     origin_identifiers->push_back(statement.ColumnString(0));
    117 
    118   return statement.Succeeded();
    119 }
    120 
    121 bool DatabasesTable::GetAllDatabaseDetailsForOriginIdentifier(
    122     const std::string& origin_identifier,
    123     std::vector<DatabaseDetails>* details_vector) {
    124   sql::Statement statement(db_->GetCachedStatement(
    125       SQL_FROM_HERE, "SELECT name, description, estimated_size "
    126                      "FROM Databases WHERE origin = ? ORDER BY name"));
    127   statement.BindString(0, origin_identifier);
    128 
    129   while (statement.Step()) {
    130     DatabaseDetails details;
    131     details.origin_identifier = origin_identifier;
    132     details.database_name = statement.ColumnString16(0);
    133     details.description = statement.ColumnString16(1);
    134     details.estimated_size = statement.ColumnInt64(2);
    135     details_vector->push_back(details);
    136   }
    137 
    138   return statement.Succeeded();
    139 }
    140 
    141 bool DatabasesTable::DeleteOriginIdentifier(
    142     const std::string& origin_identifier) {
    143   sql::Statement delete_statement(db_->GetCachedStatement(
    144       SQL_FROM_HERE, "DELETE FROM Databases WHERE origin = ?"));
    145   delete_statement.BindString(0, origin_identifier);
    146 
    147   return (delete_statement.Run() && db_->GetLastChangeCount());
    148 }
    149 
    150 }  // namespace storage
    151