SchemaReverse.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  SchemaReverse.qm Copyright 2016 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FORANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// this module requires Qore 0.8.13 or better
 
// requires the SqlUtil module
 
// requires the Util module
 
// requires the Qorize module
 
 
 
 
namespace SchemaReverse {
 
    const TYPE_TO_CLASS = ...;
 
 
    const MULTI_TO_CLASS = ...;
 
 
    const TEMPLATE = ...;
 
 
 
    class AbstractReverseObject {
 
public:
protected:
            AbstractDatasource m_ds;
            Database m_db;
            string m_name;
 
public:
 
        constructor(AbstractDatasource ds, string name);
 
 
        AbstractDatasource datasource();
 
 
        Database database();
 
 
        string name();
 
 
 
        abstract any toQore();
 
 
        string toString();
 
    }; // class AbstractReverseObject
 
class SequenceReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        hash toQore();
 
    }; // class SequenceReverse
 
 
class SequencesReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : AbstractReverseObject(ds, mask)
        {
        }
 
        hash toQore();
 
    }; // class SequencesReverse
 
class TypeReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        hash toQore();
 
    }; // class TypeReverse
 
class TypesReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : AbstractReverseObject(ds, mask)
        {
        }
 
        hash toQore();
 
    }; // class TypesReverse
 
class TableReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        hash toQore();
 
 
        any columnToQore(AbstractColumn c);
 
 
    }; // class TableReverse
 
class TablesReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : AbstractReverseObject(ds, mask)
        {
        }
 
        hash toQore();
 
    }; // class TablesReverse
 
 
class CodeBaseReverse : public AbstractReverseObject {
 
public:
protected:
            string m_object_type;
            string m_function_name;
            hash<string, bool> m_ignored_keys;
 
public:
 
        constructor(string object_type,
                    AbstractDatasource ds,
                    string name,
                    string function_name,
                    softlist ignored_keys
                   )
            : AbstractReverseObject(ds, name)
        {
            m_object_type = object_type;
            m_function_name = function_name;
            // make a hash of keys to ignore for fast lookups (to similate a set)
            m_ignored_keys = map {$1: True}, ignored_keys;
        }
 
        hash toQore();
 
    }; // class CodeBaseReverse
 
 
class CodesBaseReverse : public AbstractReverseObject {
 
public:
protected:
            string m_object_type;
            string m_function_name;
 
public:
 
        constructor(string object_type,
                    AbstractDatasource ds,
                    string mask,
                    string function_name,
                   )
            : AbstractReverseObject(ds, mask)
        {
            if (!exists TYPE_TO_CLASS{object_type});
 
            m_object_type = object_type;
            m_function_name = function_name;
        }
 
        hash toQore();
 
    }; // class CodeBaseReverse
 
class ViewReverse : public CodeBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string name)
            : CodeBaseReverse("view", ds, name, "getView", ("schema", "name", ))
        {
        }
    }; // class ViewReverse
 
class ViewsReverse : public CodesBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : CodesBaseReverse("view", ds, mask, "viewIterator")
        {
        }
    }; // class ViewsReverse
 
class MViewReverse : public CodeBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string name)
            : CodeBaseReverse("mview", ds, name, "getMaterializedView", ("schema", "name", "type"))
        {
        }
    }; // class MViewReverse
 
class MViewsReverse : public CodesBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : CodesBaseReverse("mview", ds, mask, "materializedViewIterator")
        {
        }
    }; // class MViewsReverse
 
class FunctionReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        string toQore();
 
    }; // class FunctionReverse
 
class FunctionsReverse : public CodesBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : CodesBaseReverse("function", ds, mask, "functionIterator")
        {
        }
    }; // class FunctionsReverse
 
class ProcedureReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        string toQore();
 
    }; // class ProcedureReverse
 
class ProceduresReverse : public CodesBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : CodesBaseReverse("procedure", ds, mask, "procedureIterator")
        {
        }
    }; // class ProceduresReverse
 
class PackageReverse : public AbstractReverseObject {
 
public:
        constructor(AbstractDatasource ds, string name)
            : AbstractReverseObject(ds, name)
        {
        }
 
        hash toQore();
 
    }; // class ProcedureReverse
 
class PackagesReverse : public CodesBaseReverse {
 
public:
        constructor(AbstractDatasource ds, string mask = ".*")
            : CodesBaseReverse("package", ds, mask, "packageIterator")
        {
        }
    }; // class ProceduresReverse
 
    class SchemaReverse {
 
public:
protected:
            AbstractDatasource m_ds;
            string m_class_name;
 
public:
 
        constructor(AbstractDatasource ds, string class_name);
 
 
        string toString();
 
 
    }; // class SchemaReverse
 
 
     AbstractReverseObject get_object(string object_type);
 
 
}; // namespace SchemaReverse