Changed DB to store node positions as Ordinals.

sql/connection.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/connection.h"
 
 #include <string.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "third_party/sqlite/sqlite3.h"
 #include "sql/statement.h"

[rlarocque, 2012/10/01 21:45:55]

This should be in alphabetical order.

[vishwath, 2012/10/02 01:06:33]

Done.

-#include "third_party/sqlite/sqlite3.h"
 
 namespace {
 
 // Spin for up to a second waiting for the lock to clear when setting
 // up the database.
 // TODO(shess): Better story on this.  http://crbug.com/56559
 const int kBusyTimeoutSeconds = 1;
 
 class ScopedBusyTimeout {
  public:
@@ skipping 422 matching lines @@
   sql.append(")");
 
   Statement statement(GetUntrackedStatement(sql.c_str()));
   while (statement.Step()) {
     if (!statement.ColumnString(1).compare(column_name))
       return true;
   }
   return false;
 }
 
+ColType Connection::GetColumnType(char* table_name,
+                                     int column_index) const {
+  std::string sql("PRAGMA TABLE INFO(");
+  sql.append(table_name);
+  sql.append(")");
+
+  Statement statement(GetUntrackedStatement(sql.c_str()));
+  for(int i = 0; i <= column_index; i++)
+    statement.Step();
+
+  std::string column_type = statement.ColumnString(2);

[rlarocque, 2012/10/01 21:45:55]

When I suggested the PRAGMA TABLE INFO, it didn't cross my mind that this would
result in string compares here.

sqlite3_table_column_metadata() might provide an easier to use alternative.

[vishwath, 2012/10/02 01:06:33]

It turns out that the returned information is of a higher granularity than the
'fundamental' types (integer, text, blob, null). I've changed this to just
return the exact data type (bigint, varchar, etc), so that its now the callers
responsibility to make semantic sense of that return value. I see this as an
advantage, since the callers of this function can use that extra information if
necessary.

On 2012/10/01 21:45:55, rlarocque wrote:

[rlarocque, 2012/10/02 01:39:50]

Not quite what I had in mind, but that looks OK.

I'll leave it to the SQL expert to decide if this makes sense.

+  if(column_type == "INTEGER")
+    return COLUMN_TYPE_INTEGER;
+  else if(column_type == "FLOAT")
+    return COLUMN_TYPE_FLOAT;
+  else if(column_type == "TEXT")
+    return COLUMN_TYPE_TEXT;
+  else if(column_type == "BLOB")
+    return COLUMN_TYPE_BLOB;
+
+  return COLUMN_TYPE_NULL;
+}
+
 int64 Connection::GetLastInsertRowId() const {
   if (!db_) {
     DLOG(FATAL) << "Illegal use of connection without a db";
     return 0;
   }
   return sqlite3_last_insert_rowid(db_);
 }
 
 int Connection::GetLastChangeCount() const {
   if (!db_) {
@@ skipping 137 matching lines @@
 
 int Connection::OnSqliteError(int err, sql::Statement *stmt) {
   if (error_delegate_.get())
     return error_delegate_->OnError(err, this, stmt);
   // The default handling is to assert on debug and to ignore on release.
   DLOG(FATAL) << GetErrorMessage();
   return err;
 }
 
 }  // namespace sql