text: /**
   * @file    Column_test.cpp
   * @ingroup tests
   * @brief   Test of a SQLiteCpp Column.
   *
   * Copyright (c) 2012-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
   *
   * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
   * or copy at http://opensource.org/licenses/MIT)
   */
  
  #include <SQLiteCpp/Database.h>
  #include <SQLiteCpp/Statement.h>
  #include <SQLiteCpp/Column.h>
  
  #include <sqlite3.h> // for sqlite3_int64
  
  #include <gtest/gtest.h>
  
  #include <cstdio>
  #include <stdint.h>
  
  
  TEST(Column, basis) {
      // Create a new database
      SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE);
      EXPECT_EQ(SQLite::OK, db.getErrorCode());
      EXPECT_EQ(SQLite::OK, db.getExtendedErrorCode());
  
      // Create a new table
      EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL, binary BLOB, empty TEXT)"));
      EXPECT_TRUE(db.tableExists("test"));
      EXPECT_TRUE(db.tableExists(std::string("test")));
      EXPECT_EQ(0, db.getLastInsertRowid());
  
      // Create a first row (autoid: 1) with all kind of data and a null value
      SQLite::Statement   insert(db, "INSERT INTO test VALUES (NULL, \"first\", -123, 0.123, ?, NULL)");
      // Bind the blob value to the first parameter of the SQL query
      const char  buffer[] = {'b', 'l', '\0', 'b'}; // "bl\0b" : 4 char, with a null byte inside
      const int   size = sizeof(buffer); // size = 4
      const void* blob = &buffer;
      insert.bind(1, blob, size);
      // Execute the one-step query to insert the row
      EXPECT_EQ(1, insert.exec());
      EXPECT_EQ(1, db.getLastInsertRowid());
      EXPECT_EQ(1, db.getTotalChanges());
  
      EXPECT_THROW(insert.exec(), SQLite::Exception); // exec() shall throw as it needs to be reseted
  
      // Compile a SQL query
      SQLite::Statement   query(db, "SELECT * FROM test");
      EXPECT_STREQ("SELECT * FROM test", query.getQuery().c_str());
      EXPECT_EQ(6, query.getColumnCount ());
      query.executeStep();
      EXPECT_TRUE (query.hasRow());
      EXPECT_FALSE(query.isDone());
  
      // validates every variant of cast operators, and conversions of types
      {
          const sqlite3_int64 id1     = query.getColumn(0); // operator long long()
          const int64_t       id2     = query.getColumn(0); // operator long long()
          const long long     id3     = query.getColumn(0); // operator long long()
          const long          id4     = query.getColumn(0); // operator long long() or long() depending on compiler/architecture
          const char          id5     = query.getColumn(0); // operator char()
          const short         id6     = query.getColumn(0); // operator short()
          const unsigned int  uint1   = query.getColumn(0); // operator unsigned int()
          const uint32_t      uint2   = query.getColumn(0); // operator unsigned int()
          const unsigned char uint3   = query.getColumn(0); // operator unsigned char()
          const unsigned short uint4  = query.getColumn(0); // operator unsigned short()
          const char*         ptxt    = query.getColumn(1); // operator const char*()
          const std::string   msg     = query.getColumn(1); // operator std::string() (or const char* with MSVC)
          const int           integer = query.getColumn(2); // operator int()
          const double        real    = query.getColumn(3); // operator double()
          const void*         pblob   = query.getColumn(4); // operator void*()
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
          // This implicit cast should use operator std::string()
          // but would fallback to const char* with MSVC 2010-2013 (witch does not work with the NULL char in the middle)
          const std::string   sblob   = query.getColumn(4); // operator std::string()
  #endif
          const void*         pempty  = query.getColumn(5); // operator void*()
          EXPECT_EQ(1,            id1);
          EXPECT_EQ(1,            id2);
          EXPECT_EQ(1,            id3);
          EXPECT_EQ(1,            id4);
          EXPECT_EQ(1,            id5);
          EXPECT_EQ(1,            id6);
          EXPECT_EQ(1U,           uint1);
          EXPECT_EQ(1U,           uint2);
          EXPECT_EQ(1U,           uint3);
          EXPECT_EQ(1U,           uint4);
          EXPECT_STREQ("first",   ptxt);
          EXPECT_EQ("first",      msg);
          EXPECT_EQ(-123,         integer);
          EXPECT_EQ(0.123,        real);
          EXPECT_EQ(0,            memcmp("bl\0b", pblob, size));
  #if !defined(_MSC_VER) || _MSC_VER >= 1900
          EXPECT_EQ((size_t)size, sblob.size());
          EXPECT_EQ(0,            memcmp("bl\0b", &sblob[0], size));
  #endif
          EXPECT_EQ(NULL,         pempty);
      }
  
      // validates every variant of explicit getters
      {
          int64_t             id      = query.getColumn(0).getInt64();
          const unsigned int  uint1   = query.getColumn(0).getUInt();
          const uint32_t      uint2   = query.getColumn(0).getUInt();
          const char*         ptxt    = query.getColumn(1).getText();
          const std::string   msg1    = query.getColumn(1).getText();
          const std::string   msg2    = query.getColumn(1).getString();
          const int           integer = query.getColumn(2).getInt();
          const double        real    = query.getColumn(3).getDouble();
          const void*         pblob   = query.getColumn(4).getBlob();
          const std::string   sblob   = query.getColumn(4).getString();
          EXPECT_EQ(1,            id);
          EXPECT_EQ(1U,           uint1);
          EXPECT_EQ(1U,           uint2);
          EXPECT_STREQ("first",   ptxt);
          EXPECT_EQ("first",      msg1);
          EXPECT_EQ("first",      msg2);
          EXPECT_EQ(-123,         integer);
          EXPECT_EQ(0.123,        real);
          EXPECT_EQ(0,            memcmp("bl\0b", pblob, 4));
          EXPECT_EQ(0,            memcmp("bl\0b", &sblob[0], 4));
      }
  
      // Validate getBytes(), getType(), isInteger(), isNull()...
      EXPECT_EQ(SQLite::INTEGER,  query.getColumn(0).getType());
      EXPECT_EQ(true,             query.getColumn(0).isInteger());
      EXPECT_EQ(false,            query.getColumn(0).isFloat());
      EXPECT_EQ(false,            query.getColumn(0).isText());
      EXPECT_EQ(false,            query.getColumn(0).isBlob());
      EXPECT_EQ(false,            query.getColumn(0).isNull());
      EXPECT_STREQ("1",           query.getColumn(0).getText());  // convert to string
      EXPECT_EQ(1,                query.getColumn(0).getBytes()); // size of the string "1" without the null terminator
      EXPECT_EQ(SQLite::TEXT,     query.getColumn(1).getType());
      EXPECT_EQ(false,            query.getColumn(1).isInteger());
      EXPECT_EQ(false,            query.getColumn(1).isFloat());
      EXPECT_EQ(true,             query.getColumn(1).isText());
      EXPECT_EQ(false,            query.getColumn(1).isBlob());
      EXPECT_EQ(false,            query.getColumn(1).isNull());
      EXPECT_STREQ("first",       query.getColumn(1).getText());  // convert to string
      EXPECT_EQ(5,                query.getColumn(1).getBytes()); // size of the string "first"
      EXPECT_EQ(SQLite::INTEGER,  query.getColumn(2).getType());
      EXPECT_EQ(true,             query.getColumn(2).isInteger());
      EXPECT_EQ(false,            query.getColumn(2).isFloat());
      EXPECT_EQ(false,            query.getColumn(2).isText());
      EXPECT_EQ(false,            query.getColumn(2).isBlob());
      EXPECT_EQ(false,            query.getColumn(2).isNull());
      EXPECT_STREQ("-123",        query.getColumn(2).getText());  // convert to string
      EXPECT_EQ(4,                query.getColumn(2).getBytes()); // size of the string "-123"
      EXPECT_EQ(SQLite::FLOAT,    query.getColumn(3).getType());
      EXPECT_EQ(false,            query.getColumn(3).isInteger());
      EXPECT_EQ(true,             query.getColumn(3).isFloat());
      EXPECT_EQ(false,            query.getColumn(3).isText());
      EXPECT_EQ(false,            query.getColumn(3).isBlob());
      EXPECT_EQ(false,            query.getColumn(3).isNull());
      EXPECT_STREQ("0.123",       query.getColumn(3).getText());  // convert to string
      EXPECT_EQ(5,                query.getColumn(3).getBytes()); // size of the string "0.123"
      EXPECT_EQ(SQLite::BLOB,     query.getColumn(4).getType());
      EXPECT_EQ(false,            query.getColumn(4).isInteger());
      EXPECT_EQ(false,            query.getColumn(4).isFloat());
      EXPECT_EQ(false,            query.getColumn(4).isText());
      EXPECT_EQ(true,             query.getColumn(4).isBlob());
      EXPECT_EQ(false,            query.getColumn(4).isNull());
      EXPECT_STREQ("bl\0b",       query.getColumn(4).getText());  // convert to string
      EXPECT_EQ(4,                query.getColumn(4).getBytes()); // size of the blob "bl\0b" with the null char
      EXPECT_EQ(SQLite::Null,     query.getColumn(5).getType());
      EXPECT_EQ(false,            query.getColumn(5).isInteger());
      EXPECT_EQ(false,            query.getColumn(5).isFloat());
      EXPECT_EQ(false,            query.getColumn(5).isText());
      EXPECT_EQ(false,            query.getColumn(5).isBlob());
      EXPECT_EQ(true,             query.getColumn(5).isNull());
      EXPECT_STREQ("",            query.getColumn(5).getText());  // convert to string
      EXPECT_EQ(0,                query.getColumn(5).getBytes()); // size of the string "" without the null terminator
  
      // Use intermediate Column objects (this is not the recommended way to use the API)
      {
          const SQLite::Column id = query.getColumn(0);
          EXPECT_EQ(1, id.getInt64());
          const SQLite::Column msg = query.getColumn(1);
          EXPECT_EQ("first", msg.getString());
          const SQLite::Column integer = query.getColumn(2);
          EXPECT_EQ(-123, integer.getInt());
          const SQLite::Column dbl = query.getColumn(3);
          EXPECT_EQ(0.123, dbl.getDouble());
      }
  }
  
  TEST(Column, getName) {
      // Create a new database
      SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE);
      EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT)"));
      EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\")"));
  
      // Compile a SQL query, using the "id" column name as-is, but aliasing the "msg" column with new name "value"
      SQLite::Statement   query(db, "SELECT id, msg as value FROM test");
      query.executeStep();
  
      // Show how to get the aliased names of the result columns.
      const std::string name0 = query.getColumn(0).getName();
      const std::string name1 = query.getColumn(1).getName();
      EXPECT_EQ("id",     name0);
      EXPECT_EQ("value",  name1);
  
  #ifdef SQLITE_ENABLE_COLUMN_METADATA
      // Show how to get origin names of the table columns from which theses result columns come from.
      // Requires the SQLITE_ENABLE_COLUMN_METADATA preprocessor macro to be
      // also defined at compile times of the SQLite library itself.
      const std::string oname0 = query.getColumn(0).getOriginName();
      const std::string oname1 = query.getColumn(1).getOriginName();
      EXPECT_EQ("id",     oname0);
      EXPECT_EQ("msg",    oname1);
  #endif
  }
  
  TEST(Column, stream) {
      // Create a new database
      SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE);
      EXPECT_EQ(0, db.exec("CREATE TABLE test (msg TEXT)"));
      SQLite::Statement insert(db, "INSERT INTO test VALUES (?)");
  
      // content to test
      const char str_[] = "stringwith\0embedded";
      std::string str(str_, sizeof(str_)-1);
  
      insert.bind(1, str);
      // Execute the one-step query to insert the row
      EXPECT_EQ(1, insert.exec());
      EXPECT_EQ(1, db.getTotalChanges());
  
      SQLite::Statement query(db, "SELECT * FROM test");
      query.executeStep();
      std::stringstream ss;
      ss << query.getColumn(0);
      std::string content = ss.str();
      EXPECT_EQ(content, str);
  }
  