CifSchemaMap.h

Go to the documentation of this file.

/*$$FILE$$*/
/*$$VERSION$$*/
/*$$DATE$$*/
/*$$LICENSE$$*/


#ifndef CIFSCHEMAMAP_H
#define CIFSCHEMAMAP_H


#include <string>

#include "CifFile.h"


typedef struct _attribInfo
{
    int iIndex;
    int iNull;
    int iWidth;
    int iPrecision;
    unsigned int iMaxWidth; 
    string dType;
    int iTypeCode;
} ATTRIBINFO;


typedef struct
{
    string attribName;
    string dataType;
    string indexFlag;
    string nullFlag;
    string width;
    string precision;
    string populated;   // Not taken from the file, but constructed afterwards
} AttrInfo;


class SchemaMapping
{

  public:
    // TODO - All these constants can be made
    // private, except _TYPE_CODE_TEXT that is used outside of this
    // class. Try to fix that and move all these constants to private
    static const int _TYPE_CODE_INT        = 1;
    static const int _TYPE_CODE_FLOAT      = 2;
    static const int _TYPE_CODE_STRING     = 3;
    static const int _TYPE_CODE_TEXT       = 4;
    static const int _TYPE_CODE_DATETIME   = 5;
    static const int _TYPE_CODE_BIGINT     = 6;

    static const int _MAX_LINE_LENGTH = 255;

    SchemaMapping(const string& schemaFile = String::Empty,
      const string& schemaFileOdb = String::Empty, bool verbose = false);

    virtual ~SchemaMapping();

    void SetReviseSchemaMode(bool mode = true);

    bool GetReviseSchemaMode();

    void ReviseSchemaMap(const string& revisedSchemaFile);


    void updateSchemaMapDetails(SchemaMapping& revSchMap);

    void CreateTables(CifFile& cifFile, const string& blockName);

    void GetTableNames(vector<string>& tableNames);

    ISTable* CreateTableInfo();
    ISTable* CreateColumnInfo();

    void GetAttributeNames(vector<string>& attributes,
      const string& tableName);
    void GetAttributesInfo(vector<AttrInfo>& attrInfo,
      const string& tableName);
    void GetMappedAttributesInfo(vector<vector<string> >& mappedAttrInfo,
      const string& tableName);

    void GetMappedConditions(vector<vector<string> >& mappedConditions,
      const string& tableName);

    void GetTableNameAbbrev(string &abbrev, string target);
    void GetAttributeNameAbbrev(string &abbrev, string targetTable,
      string targetAttribute);

    void getSchemaMapDetails(const string& tableName,
      const string& attribName, string& dataType,
      string& indexFlag, string& nullFlag,
      string& width, string& precision, string& populated);

    void UpdateAttributeDef(const string& tableName, const string& columnName,
      int type, int iWidth, int newWidth);

    void GetAttributeInfo(vector<ATTRIBINFO>& aI, ISTable *tIn);
    void GetAllAttributeInfo(vector<ATTRIBINFO>& aI, string tableName);

    static bool AreAttributesMandatory(const vector<string>& row,
      const vector<ATTRIBINFO>& aI);
    static bool IsTablePopulated(const vector<AttrInfo>& attrInfo);
    void GetMasterIndexAttribName(string& masterIndexAttribName);
    static int CheckIndexAttributes(const vector<string>& row,
      const vector<ATTRIBINFO>& aI);

  private:
    bool _verbose;

    string _schemaFile;    // Schema definition file name (mmCIF)
    string _schemaFileOdb; // Schema definition file name (odb)

    CifFile* _fobjS;

    ISTable* _tableSchema;
    ISTable* _attribSchema;
    ISTable* _schemaMap;
    ISTable* _mapConditions;
    ISTable* _tableAbbrev;    
    ISTable* _attributeAbbrev;

    bool _reviseSchemaMode;
    int  _compatibilityMode;

    void _AssignAttribIndices(void);
    void GetGroupNames(vector<string>& groupNames);

    void Clear();
};


class Db
{
  public:
    static const string DB_DEFAULT_NAME;

    SchemaMapping& _schemaMapping;

    Db(SchemaMapping& schemaMapping, const string& dbName = DB_DEFAULT_NAME);
    virtual ~Db();

    void SetUseOnlyPopulated(bool mode=true);
    bool GetUseOnlyPopulated();

    void SetAppendFlag(const bool appendFlag);
    bool GetAppendFlag();

    void SetFieldSeparator(const string& fieldSeparator);
    void SetRowSeparator(const string& rowSeparator);

    string GetCommandTerm();

    string GetFieldSeparator();
    string GetRowSeparator();

    virtual void GetStart(string& start);

    virtual void WriteSchemaStart(ostream& io);
    void WriteDeleteTable(ostream& io, const string& table,
      const string& where, const string& what);

    virtual void DropTableSql(ostream& io, const string& tableNameDb);

    virtual const string& GetExec();
    virtual const string& GetExecOption();
    virtual const string& GetUserOption();
    virtual const string& GetPassOption();

    virtual const string& GetEnvDbUser();
    virtual const string& GetEnvDbPass();

    virtual const string& GetConnect();
    virtual const string& GetTerminate();
    virtual const string& GetDbCommand();

    virtual void WriteLoad(ostream& io);

    const string& GetDataLoadingFileName();

    virtual void WriteLoadingStart(ostream& io);
    virtual void WriteLoadingEnd(ostream& io);
    virtual void WriteLoadingTable(ostream& io, const string& tableName,
      const string& path);

    virtual void WritePrint(ostream& io, const string& tableNameDb);

    virtual void GetChar(string& dType, const unsigned int width);
    virtual void GetFloat(string& dType);
    virtual void GetText(string& dType, const unsigned int width);
    virtual void GetDate(string& dType);
    virtual void WriteNull(ostream& io, const int iNull,
      const unsigned int curr, const unsigned int attSize);
    virtual void WriteTableIndex(ostream& io, const string& tableNameDb,
      const vector<string>& indexList);

    const string& GetBcpStringDelimiter();
    virtual void WriteBcpDoubleQuotes(ostream& io);

    virtual void WriteNewLine(ostream& io, bool special = false);

    bool IsFirstTextNewLineSpecial();

    virtual void ConvertDate(string& dbDate, const string& cifDate);
    virtual void ConvertTimestamp(string& dbTimestamp,
      const string& cifTimestamp);

  protected:
    bool _useOnlyPopulated;

    bool _appendFlag;

    // Field and row separators for compact output (eg. BCP)
    string _fieldSeparator; 
    string _rowSeparator;   

    string _cmdTerm;            // SQL command terminator.

    // Used in assigning permissions when exporting schema in SQL. 
    string _dbName; // Target database name 

    string _exec;
    string _execOption;
    string _userOption;
    string _passOption;

    string _connect;
    string _terminate;
    string _dbCommand;
    string _envDbUser;
    string _envDbPass;

    string _dataLoadingFileName;

    string _bcpStringDelimiter;

    bool _firstTextNewLineSpecial;

  private:
    static const string _SCRIPT_LOADING_FILE;

};


class DbOracle : public Db
{

  // Oracle 8.1.6 SQLLDR

  public:
    DbOracle(SchemaMapping& schemaMapping,
      const string& dbName = DB_DEFAULT_NAME);
    ~DbOracle();

    void WriteSchemaStart(ostream& io);

    void WriteLoadingStart(ostream& io);
    void WriteLoadingTable(ostream& io, const string& tableName,
      const string& path);

    void GetDate(string& dType);
    void GetText(string& dType, const unsigned int width);

    void WriteNull(ostream& io, const int iNull,
      const unsigned int curr, const unsigned int attSize);
    void WriteTableIndex(ostream& io, const string& tableNameDb,
      const vector<string>& indexList);

    void WriteNewLine(ostream& io, bool special = false);
};


class DbDb2 : public Db
{

  public:
    DbDb2(SchemaMapping& schemaMapping,
      const string& dbName = DB_DEFAULT_NAME);
    ~DbDb2();


    void GetStart(string& start);

    void WriteSchemaStart(ostream& io);

    void WriteLoadingStart(ostream& io);
    void WriteLoadingEnd(ostream& io);
    void WriteLoadingTable(ostream& io, const string& tableName,
      const string& path);

    void GetFloat(string& dType);
    void GetDate(string& dType);
    void GetText(string& dType, const unsigned int width);
    void WriteNull(ostream& io, const int iNull,
      const unsigned int curr, const unsigned int attSize);

    void WriteTableIndex(ostream& io, const string& tableNameDb,
      const vector<string>& indexList);

    void WriteBcpDoubleQuotes(ostream& io);
};


class DbMySql : public Db
{

  public:
    DbMySql(SchemaMapping& schemaMapping,
      const string& dbName = DB_DEFAULT_NAME);
    ~DbMySql();

    void GetStart(string& start);

    void DropTableSql(ostream& io, const string& tableNameDb);

    void WriteLoad(ostream& io);
    void WriteLoadingStart(ostream& io);
    void WriteLoadingTable(ostream& io, const string& tableName,
      const string& path);

    void WriteTableIndex(ostream& io, const string& tableNameDb,
      const vector<string>& indexList);

    void WriteNull(ostream& io, const int iNull,
      const unsigned int curr, const unsigned int attSize);

    void WriteNewLine(ostream& io, bool special = false);

  private:
    static const string _SQL_LOADING_FILE;

};


class DbSybase : public Db
{
  public:
    DbSybase(SchemaMapping& schemaMapping,
      const string& dbName = DB_DEFAULT_NAME);
    ~DbSybase();

    void GetStart(string& start);

    void WriteLoadingStart(ostream& io);
    void WriteLoadingTable(ostream& io, const string& tableName,
      const string& path);

    void WritePrint(ostream& io, const string& tableNameDb);
    void WriteNull(ostream& io, const int iNull,
      const unsigned int curr, const unsigned int attSize);

    void WriteTableIndex(ostream& io, const string& tableNameDb,
      const vector<string>& indexList);

#ifdef VLAD_DATE_OBSOLETE
    void ConvertDate(string& dbDate, const string& cifDate);
#endif
};


class DbOutput
{

  public:
    Db& _db;

    DbOutput(Db& db);
    virtual ~DbOutput();

    virtual void WriteSchema(const string& path = String::Empty);
    virtual void WriteDataLoadingScripts(const string& path = String::Empty);
    virtual void WriteData(Block& block, const string& path = String::Empty);

    void SetInputFile(const string& inpFile);

    const string& GetCommandScriptName();

  protected:
    static const string _DATA_LOADING_SCRIPT;

    string _SCHEMA_FILE;

    string _INPUT_FILE;

    string _stringDelimiter;
    vector<char> _specialChars;

    string _dateDelimiter;
    vector<char> _specialDateChars;

    string _itemSeparator; 
    string _rowSeparator; 

    void WriteDbExec(ostream& io, const string& fileName,
      const unsigned int indentLevel = 0);
    void WriteDbExecOnly(ostream& io, const string& fileName,
      const unsigned int indentLevel = 1);

    void WriteHeader(ostream& io);

    void _FormatNumericData(ostream &io, const string &cs);
    void _FormatStringData(ostream &io, const string &cs,
      unsigned int maxWidth);
    void _FormatTextData(ostream &io, const string &cs);
    void _FormatDateData(ostream &io, const string &cs, unsigned int maxWidth);

    void _FormatData(ostream &io, const string &cs,
      ATTRIBINFO& attribInfo, const bool noRevise);

    bool IsSpecialChar(const char& character);
    bool IsSpecialDateChar(const char& character);

    virtual void WriteEmptyNumeric(ostream& io);
    virtual void WriteEmptyString(ostream& io);
    virtual void WriteSpecialChar(ostream& io, const char& specChar);

    virtual void WriteEmptyDate(ostream& io);
    virtual void WriteSpecialDateChar(ostream& io, const char& specDateChar);

    virtual bool IsFirstTextNewLineSpecial();
    virtual void WriteNewLine(ostream& io, bool special = false);

    virtual void GetTableStart(string& tableStart, const string& tableName);
    virtual void GetTableEnd(string& tableEnd);
    const string& GetItemSeparator();
    const string& GetRowSeparator();

    virtual void _WriteTable(ostream& io, ISTable* tIn, bool noRevise = false);
    void GetMasterIndexAttribValue(string& masterIndexAttribValue,
      Block& block, const string& masterIndexAttribName,
      const vector<string>& tableNames);

  private:
    static void _FormatStringDataSql(ostream &io, const string &cs,
      unsigned int maxWidth);

};


class BcpOutput : public DbOutput
{
  public:
    BcpOutput(Db& db);
    virtual ~BcpOutput();

    void WriteDataLoadingScripts(const string& path = String::Empty);
    void WriteData(Block& block, const string& path = String::Empty);

  private:
    static const string _DATA_DELETE_FILE;

    void WriteDataLoadingScript(const string& path);
    void WriteDataLoadingFile(const string& path = String::Empty);

    void WriteDelete(ostream& io);

    void WriteEmptyString(ostream& io);

    void WriteSpecialDateChar(ostream& io, const char& specDateChar);
};
 

class SqlOutput : public DbOutput
{

  public:
    SqlOutput(Db& db);
    virtual ~SqlOutput();

    void WriteSchema(const string& path = String::Empty);
    void WriteDataLoadingScripts(const string& path = String::Empty);
    void WriteData(Block& block, const string& path = String::Empty);

  protected:
    void WriteEmptyNumeric(ostream& io);
    bool IsFirstTextNewLineSpecial();
    void WriteNewLine(ostream& io, bool special = false);
    void GetTableStart(string& tableStart, const string& tableName);
    void GetTableEnd(string& tableEnd);

  private:
    static const unsigned int _MAX_SQL_NAME_LENGTH = 60;
    static const string _SCHEMA_LOADING_SCRIPT;
    static const string _SCHEMA_DELETE_FILE;
    static const string _DATA_FILE;

    void WriteSqlScriptSchemaInfo(ostream& io);
    void WriteDataLoadingScript(const string& path);

    void CreateTableSql(ostream& io, const string& tableName,
      const vector<AttrInfo>& attrInfo);

    void WriteAuxTables(ostream& io, ISTable* infoP,
      const vector<string>& tableNames);

    void WriteEmptyString(ostream& io);
    void WriteEmptyDate(ostream& io);
};


class XmlOutput : public DbOutput
{
  public:
    XmlOutput(Db& db);
    virtual ~XmlOutput();

    void WriteSchema(const string& path = String::Empty);
    void WriteData(Block& block, const string& path = String::Empty);

  private:
    static const int _MAX_NAME_LENGTH = 80;
    string _NS_DEFAULT;

    void _CreateComplexTypeXML(ostream &io, const string& tableName);
    void _SetNamespaceDefaultXML(const string& name); 
    void _GetDefaultNamespaceXML(ostream &io); 
    void _WriteTable(ostream& io, ISTable* tIn, bool noRevise = false);

    void _GetAttributeNameAbbrevXML(string &abbrev,
      const string& targetAttribute);
    void _QualifyNameXML(ostream &io,  const string& name); 

    void _GetTableNameAbbrevXML(string &abbrev, string target);

    void WriteSpecialChar(ostream& io, const char& specChar);
};


class DbLoader
{
  public:
    enum eConvOpt
    {
        // Generate only data loading files
        eDATA_ONLY = 0,

        // Generate both data loading files and loading shell scripts
        eDATA_WITH_SCRIPTS,

        // Generate only loading shell scripts
        eSCRIPTS_ONLY
    };

    DbLoader(SchemaMapping& schemaMapping, DbOutput& dbOutput,
      bool verbose = false, const string& workDir = String::Empty);

    virtual ~DbLoader();

    void SetWorkDir(const string& workDir);

    void AsciiFileToDb(const string& asciiFile, const eConvOpt convOpt);

    void SerFileToDb(const string& serFile, const eConvOpt convOpt);

    void FileObjToDb(CifFile& cifFile, const eConvOpt convOpt);

    static unsigned int GetTableColumnIndex(const ISTable& isTable,
      const string& colName);

#ifdef DB_HASH_ID
    void SetHashMode(int mode);
#endif

  private:
    static const string _LOG_FILE;

    string _workDir; // Working directory for all generated files.
    string _INPUT_FILE;

#ifdef DB_HASH_ID
    string _HASH_ID;
    int _hashMode;
#endif

    // Block name of loadable data in mmCIF format
    string _blockName;

    bool _verbose;

    ofstream _log;

    SchemaMapping& _schemaMapping;
    DbOutput& _dbOutput;

    void _LoadBlock(Block& rBlock, Block& wBlock);
    bool _Search(vector<vector<string> >& dMap, const unsigned int iAttr,
      ISTable* isTableP, const string& blockName,
      const vector<string>& cNameMap, const string& sItem,
      const string& sCnd, const string& sFnct);
 
    void _DoFunc(vector<string>& s, const vector<string>& r,
      const string& sFnct);

    void _OpenLog(const string& logName);

    int _GetMapColumnIndex(const vector<string>& cNameMap, const string& vOf);
    void _GetMapColumnValue(string& p, vector<vector<string> >& dMap,
      int iCol, int irow);
    int _GetMapColumnLength(vector<vector<string> >& dMap,   int iCol);

#ifdef VLAD_DATE_OBSOLETE
    void _dformat_1(const char *date, char *odate);
    void _dformat_2(const char *date, char *odate);
    void _dformat_3(const char *date, char *odate, int shortFlag);
    void _dformat_4(const char *date, char *odate);
    void _dformat_5(const char *date, char *odate);
#endif

    void _ReorderName(string& res, char *string, int mode);
    void _ToUpperString(string& aString);
    void _StripString(string& aString, int mode);

    int _CheckNullRow(const vector<string>& row, const vector<ATTRIBINFO>& aI);

#ifdef DB_HASH_ID
    long long pdbIdHash(const string& id);
#endif

    static void CleanString(string& aString);

    void Clear();
};


#endif

---