databaseColumn.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef databaseColumn_H_
#define databaseColumn_H_

#include "vlDatabase.h"


#include <list>
#include <vlutil/vlString.h>
#include <vector>


// DtDatabaseColumn represents a single column in an SQL database table. It
// has a storage type from the enumerated list above, plus any of several
// attributes such as being a primary or secondary key; a display size; default
// value; et. al.  The class has a stringRep() method that, once the attributes
// of the column have been defined, will provide a string that can be used as
// part of an SQL CREATE TABLE query for defining the column.
class DT_DLL_VLDB DtDatabaseColumn
{
public:
   // enumeration of storage types supported (note that this is not an
   // exhaustive list of what SQL can support; rather, it's a list of
   // useful types for our application).
   enum DataType
   {
      Type_SqlNone         = 0, // Nothing (not a type)
      Type_SqlChar         = 1, // a char treated as an 8-bit integer
      Type_SqlShort        = 2,
      Type_SqlInt          = 3,
      Type_SqlLong         = 4,
      Type_SqlFloat        = 5,
      Type_SqlDouble       = 6,
      Type_SqlFixedString  = 7,
      Type_SqlVarString    = 8,
      Type_SqlIndex        = 9, // not really a storage type, but a special column
                                // type that refers to a multi-column index (key).
      Type_SqlEnum8     = 10,
      Type_SqlEnum16    = 11,
      Type_SqlEnum32    = 12,
      Type_SqlBool      = 13,
      Type_SqlUnsignedShort = 15,
      Type_SqlUnsignedInt = 16,
      Type_SqlUnsignedLong = 17
   };

   typedef std::list<DtString> IndexNameList;

   // Main constructor
   DtDatabaseColumn(const DtString& columnName, DataType columnType );

   // Destructor
   virtual ~DtDatabaseColumn();

   // Copy constructor
   DtDatabaseColumn( const DtDatabaseColumn& src );

   // Assignment operator
   virtual DtDatabaseColumn& operator=(const DtDatabaseColumn& src );

   // return the name of this column
   const DtString& columnName() const;
   virtual void setColumnName(const DtString&);

   // return the (storage) type of this column
   DataType columnType() const;
   virtual void setColumnType(DataType type);

   // return true if this column has a display size specified
   bool hasDisplaySize() const;

   // return true if this column has a default value specified
   bool hasDefaultValue() const;

   // Set / get common SQL field attributes

   // the width of the display field for this column
   int displaySize() const;
   void setDisplaySize(int displaySize );

   // the number of decimals to show (only applies to floats / doubles)
   int numDecimals() const;
   void setNumDecimals( int numDecimals );

   // is this field unsigned?
   bool isUnsigned() const;
   void setIsUnsigned( bool isUnsigned );

   // can this field have un-set (null) values?
   bool nullAllow() const;
   void setNullAllow( bool nullAllow );

   // Is there a default value for this field?  This is specifed as
   // a string to be type independent.
   const DtString& defaultValue() const;
   void setDefaultValue( const DtString& defaultValue );

   // Is this an auto-increment field? (auto-increment fields automatically
   // count up, such as a record number).
   bool autoIncrement() const;
   void setAutoIncrement( bool autoIncrement );

   // Is this field a table's primary key
   bool isPrimaryKey() const;
   void setIsPrimaryKey( bool isPrimaryKey );

   // Is this field a secondary key for a table?
   bool isSecondaryKey() const;
   void setIsSecondaryKey( bool isSecondaryKey );

   // If the column is an index definition, this is the list of column
   // names that makes up that index
   const IndexNameList& indexNameList() const;

   // Add a column name to an index column
   void addIndexName( const DtString& indexName );

   // clear the index name list
   void clearIndexNameList();

   // Get the current value.
   const DtString& value() const;

   // Set the current value.
   void setValue(const DtString& value);

   // Get the number of values.
   int valueCount() const;

   // Get a specific value.
   const DtString& value(size_t index) const;

   // Add a new value.
   void addValue(const DtString& value);

   // Get to see if the value is null.
   bool isNull(size_t index) const;

   // Get the data type for the native C/C++ type.
   static DataType dataTypeFromNativeType(const DtString& naticeCType);

   static DtString& nullString();

protected:

   static DtString theNullString;

   DtString myColumnName;
   DtString myDefaultValue;

   std::vector<DtString> myStringReps;
   IndexNameList myIndexNameList;

   DataType myColumnType;

   int myDisplaySize;
   int myNumDecimals;

   bool myAutoIncrement;
   bool myHasDefaultValue;
   bool myHasDisplaySize;
   bool myIsPrimaryKey;
   bool myIsSecondaryKey;
   bool myIsUnsigned;
   bool myNullAllow;

};


#endif