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);
  static vtkSQLDatabaseSchema* New();
 
  //BTX
 
  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
    };
  //ETX
 
 
  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);
 
  //BTX
  // 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, ... );
  //ETX
 
 protected:
  vtkSQLDatabaseSchema();
  ~vtkSQLDatabaseSchema();
 
  char* Name;
//BTX
  class vtkSQLDatabaseSchemaInternals* Internals;
//ETX
 
 private:
  vtkSQLDatabaseSchema(const vtkSQLDatabaseSchema &); // Not implemented.
  void operator=(const vtkSQLDatabaseSchema &); // Not implemented.
};
 
#endif // vtkSQLDatabaseSchema_h