vtkSQLDatabaseSchema.h

Go to the documentation of this file.

/*=========================================================================
 
Program:   Visualization Toolkit
Module:    vtkSQLDatabaseSchema.h
 
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
/*-------------------------------------------------------------------------
  Copyright 2008 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
#ifndef vtkSQLDatabaseSchema_h
#define vtkSQLDatabaseSchema_h
 
#include "vtkIOSQLModule.h" // For export macro
#include "vtkObject.h"
 
#include <cstdarg> // Because one method has a variable list of arguments
 
// This is a list of known supported VTK SQL backend classes.
// A particular SQL backend does not have to be listed here to be supported, but
// these macros allow for the specification of SQL backend-specific database schema items.
#define VTK_SQL_ALLBACKENDS "*" // works for all backends
#define VTK_SQL_MYSQL "vtkMySQLDatabase"
#define VTK_SQL_POSTGRESQL "vtkPostgreSQLDatabase"
#define VTK_SQL_SQLITE "vtkSQLiteDatabase"
 
class vtkSQLDatabaseSchemaInternals;
 
class VTKIOSQL_EXPORT vtkSQLDatabaseSchema : public vtkObject
{
public:
  vtkTypeMacro(vtkSQLDatabaseSchema, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkSQLDatabaseSchema* New();
 
  enum DatabaseColumnType
  {
    SERIAL = 0, // specifying the indices explicitly to prevent bad compiler mishaps
    SMALLINT = 1,
    INTEGER = 2,
    BIGINT = 3,
    VARCHAR = 4,
    TEXT = 5,
    REAL = 6,
    DOUBLE = 7,
    BLOB = 8,
    TIME = 9,
    DATE = 10,
    TIMESTAMP = 11
  };
 
  enum DatabaseIndexType
  {
    INDEX = 0,  // Non-unique index of values in named columns
    UNIQUE = 1, // Index of values in named columns required to have at most one entry per pair of
                // valid values.
    PRIMARY_KEY = 2 // Like UNIQUE but additionally this serves as the primary key for the table to
                    // speed up insertions.
  };
 
  enum DatabaseTriggerType
  {
    BEFORE_INSERT = 0, // Just before a row is inserted
    AFTER_INSERT = 1,  // Just after a row is inserted
    BEFORE_UPDATE = 2, // Just before a row's values are changed
    AFTER_UPDATE = 3,  // Just after a row's values are changed
    BEFORE_DELETE = 4, // Just before a row is deleted
    AFTER_DELETE = 5   // Just after a row is deleted
  };
 
  virtual int AddPreamble(
    const char* preName, const char* preAction, const char* preBackend = VTK_SQL_ALLBACKENDS);
 
  virtual int AddTable(const char* tblName);
 
 
  virtual int AddColumnToTable(
    int tblHandle, int colType, const char* colName, int colSize, const char* colAttribs);
  virtual int AddColumnToTable(
    const char* tblName, int colType, const char* colName, int colSize, const char* colAttribs)
  {
    return this->AddColumnToTable(
      this->GetTableHandleFromName(tblName), colType, colName, colSize, colAttribs);
  }
 
 
  virtual int AddIndexToTable(int tblHandle, int idxType, const char* idxName);
  virtual int AddIndexToTable(const char* tblName, int idxType, const char* idxName)
  {
    return this->AddIndexToTable(this->GetTableHandleFromName(tblName), idxType, idxName);
  }
 
 
  virtual int AddColumnToIndex(int tblHandle, int idxHandle, int colHandle);
  virtual int AddColumnToIndex(const char* tblName, const char* idxName, const char* colName)
  {
    int tblHandle = this->GetTableHandleFromName(tblName);
    return this->AddColumnToIndex(tblHandle, this->GetIndexHandleFromName(tblName, idxName),
      this->GetColumnHandleFromName(tblName, colName));
  }
 
 
  virtual int AddTriggerToTable(int tblHandle, int trgType, const char* trgName,
    const char* trgAction, const char* trgBackend = VTK_SQL_ALLBACKENDS);
  virtual int AddTriggerToTable(const char* tblName, int trgType, const char* trgName,
    const char* trgAction, const char* trgBackend = VTK_SQL_ALLBACKENDS)
  {
    return this->AddTriggerToTable(
      this->GetTableHandleFromName(tblName), trgType, trgName, trgAction, trgBackend);
  }
 
 
  virtual int AddOptionToTable(
    int tblHandle, const char* optStr, const char* optBackend = VTK_SQL_ALLBACKENDS);
  virtual int AddOptionToTable(
    const char* tblName, const char* optStr, const char* optBackend = VTK_SQL_ALLBACKENDS)
  {
    return this->AddOptionToTable(this->GetTableHandleFromName(tblName), optStr, optBackend);
  }
 
  int GetPreambleHandleFromName(const char* preName);
 
  const char* GetPreambleNameFromHandle(int preHandle);
 
  const char* GetPreambleActionFromHandle(int preHandle);
 
  const char* GetPreambleBackendFromHandle(int preHandle);
 
  int GetTableHandleFromName(const char* tblName);
 
  const char* GetTableNameFromHandle(int tblHandle);
 
  int GetIndexHandleFromName(const char* tblName, const char* idxName);
 
  const char* GetIndexNameFromHandle(int tblHandle, int idxHandle);
 
  int GetIndexTypeFromHandle(int tblHandle, int idxHandle);
 
  const char* GetIndexColumnNameFromHandle(int tblHandle, int idxHandle, int cnmHandle);
 
  int GetColumnHandleFromName(const char* tblName, const char* colName);
 
  const char* GetColumnNameFromHandle(int tblHandle, int colHandle);
 
  int GetColumnTypeFromHandle(int tblHandle, int colHandle);
 
  int GetColumnSizeFromHandle(int tblHandle, int colHandle);
 
  const char* GetColumnAttributesFromHandle(int tblHandle, int colHandle);
 
  int GetTriggerHandleFromName(const char* tblName, const char* trgName);
 
  const char* GetTriggerNameFromHandle(int tblHandle, int trgHandle);
 
  int GetTriggerTypeFromHandle(int tblHandle, int trgHandle);
 
  const char* GetTriggerActionFromHandle(int tblHandle, int trgHandle);
 
  const char* GetTriggerBackendFromHandle(int tblHandle, int trgHandle);
 
  const char* GetOptionTextFromHandle(int tblHandle, int optHandle);
 
  const char* GetOptionBackendFromHandle(int tblHandle, int trgHandle);
 
  void Reset();
 
  int GetNumberOfPreambles();
 
  int GetNumberOfTables();
 
  int GetNumberOfColumnsInTable(int tblHandle);
 
  int GetNumberOfIndicesInTable(int tblHandle);
 
  int GetNumberOfColumnNamesInIndex(int tblHandle, int idxHandle);
 
  int GetNumberOfTriggersInTable(int tblHandle);
 
  int GetNumberOfOptionsInTable(int tblHandle);
 
 
  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);
 
  // Tokens passed to AddTable to indicate the type of data that follows. Random integers chosen to
  // prevent mishaps.
  enum VarargTokens
  {
    COLUMN_TOKEN = 58,
    INDEX_TOKEN = 63,
    INDEX_COLUMN_TOKEN = 65,
    END_INDEX_TOKEN = 75,
    TRIGGER_TOKEN = 81,
    OPTION_TOKEN = 86,
    END_TABLE_TOKEN = 99
  };
 
  int AddTableMultipleArguments(const char* tblName, ...);
 
protected:
  vtkSQLDatabaseSchema();
  ~vtkSQLDatabaseSchema() override;
 
  char* Name;
 
  class vtkSQLDatabaseSchemaInternals* Internals;
 
private:
  vtkSQLDatabaseSchema(const vtkSQLDatabaseSchema&) = delete;
  void operator=(const vtkSQLDatabaseSchema&) = delete;
};
 
#endif // vtkSQLDatabaseSchema_h