entitycopy/main.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#if __DCL_WINDOWS
#include <windows.h>
#endif
 
#include <locale.h>
 
#include <dcl/FileWriter.h>
#include <dcl/Arguments.h>
#include <dcl/DateTime.h>
 
#include "main.h"
#include "EntityCopy.h"
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("entitycopy/main.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
static Arguments::Option __options__[] =
{
    { L"verbose",   L'v', NULL,         0,  L"Produce verbose output" },
    { NULL,         0,    NULL,         0,  L"The following options should be grouped together:" },
    { L"source",    L's', L"STRING",    0,  L"Source database connection."
            "\n\t\t\t    DRIVER=DCLFirebird; USER=MT100;PASSWORD=pass;SERVER=g02u24kn2/32055;DATABASE=MT100" },
    { L"destination", L'd', L"STRING",  0,  L"Destination database connection."
            "\n\t\t\t    DRIVER=DCLInterBase;USER=MT100;PASSWORD=pass;SERVER=n0317ud70p/3050;DATABASE=MT100" },
    { L"entities",  L'e',   L"STRING",  0,  L"Entity configuration list."
            "\n\t\t\t    Blank(all) or S1;S2;S3(c1,cn);S4(s1,sn)=D4(d1,dn); ..." },
    { L"truncate",  L'c',   NULL,       0,  L"Truncate table and insert" },
    { L"rows",      L'r',   L"NUMBER",  0,  L"Rows per transaction." },
    { L"i4-precision", L'4', L"NUMBER", 0,  L"32bits integer precision for decimal. default is 10" },
    { L"i8-precision", L'8', L"NUMBER", 0,  L"64bits integer precision for decimal, default is 19" },
    { L"dry-run",   L'n',   NULL,       0,  L"perform a trial run with no changes made" },
    { NULL }
};
 
MainArguments::MainArguments(Writer& _output, Writer& _errout)
    : Arguments(
        _output, _errout,
        L"entitycopy 1.0",
        L"daejung@gowoonsoft.com",
        NULL,
        L"Copy Database Tables",
        __options__
    )
{
    __dryrun = false;
    __verbose = false;
    __truncate = false;
    __rows = -1;
    __i4precision = 10;
    __i8precision = 19;
}
 
String MainArguments::toString() const
{
    StringBuilder sb;
    sb.append(value0())
        .append(L" --verbose=").append(String::valueOf(__verbose))
        .append(L" --source=").append(__source)
        .append(L" --destination=").append(__destination)
        .append(L" --entities=").append(__entities)
        .append(L" --truncate=").append(String::valueOf(__truncate))
        .append(L" --rows=").append(String::valueOf(__rows))
        .append(L" --i4-precision=").append(String::valueOf(__i4precision))
        .append(L" --i8-precision=").append(String::valueOf(__i8precision))
        .append(L" --dry-run=").append(String::valueOf(__dryrun))
        .append(L" values[").append(values().toString())
        .append(L"]");
 
    return sb;
}
 
void MainArguments::onOption(int _key, const String& _arg)
        __DCL_THROWS1(Exception*)
{
    switch (_key) {
        case L'v':
            __verbose = true;
            break;
        case L's':
            __source = _arg;
            break;
        case L'd':
            __destination = _arg;
            break;
        case L'e':
            __entities = _arg;
            break;
        case L'c':
            __truncate = true;
            break;
        case L'r':
            __rows = Int32::parse(_arg.data());
            break;
        case L'4':
            __i4precision = Int32::parse(_arg.data(), 10, __i4precision);
            break;
        case L'8':
            __i8precision = Int32::parse(_arg.data(), 10, __i8precision);
            break;
        case L'n':
            __dryrun = true;
            break;
    }
}
 
String MainArguments::onValidate()
{
    if (__source.isEmpty() || __destination.isEmpty()) {
        return L"option '--source' and '--destination' must both be provided";
    }
    return Arguments::onValidate();
}
 
void __main(const MainArguments& _args)
{
    String srcDriver;
    String dstDriver;
    {
        String s = _args.source().substring(L"DRIVER *= *[^ ;]+", true);
        if (!s.isEmpty()) {
            srcDriver = s.substring(s.indexOf(L'=') + 1).trim();
        }
        s = _args.destination().substring(L"DRIVER *= *[^ ;]+", true);
        if (!s.isEmpty()) {
            dstDriver = s.substring(s.indexOf(L'=') + 1).trim();
        }
    }
 
    if (srcDriver.isEmpty() || dstDriver.isEmpty()) {
        _args.errout() << _args.value0() << L": option '--source' or '--destination' is invalid"
            << endl << _args.tryUsage() << endl;
        return;
    }
 
    EntityCopy copy(_args, srcDriver, dstDriver);
    if (copy.initialize()) {
        copy.doIt();
    }
}
 
__DCL_END_NAMESPACE
 
__DCL_USING_NAMESPACE
 
int main(int _argc, char* _argv[])
{
    // std::locale::global(std::locale(""));
    setlocale(LC_ALL, "");
 
    __DCL_INITIALIZE
    {
        FileWriter output(STDOUT_HANDLE);
        FileWriter errout(STDERR_HANDLE);
#if __DCL_DEBUG
        DCLDebugSetGlobalReport(&errout);
#endif
        MainArguments args(output, errout);
        if (args.parse(_argc, _argv, false)) {
            String sep(L'=', 80);
            DateTime start = DateTime::getCurrentLocalTime();
            output << L"Start [" << start.toString()
                << L"]" << endl;
            if (args.verbose()) {
                output << L"      [" << args.toString() << L"]" << endl;
            }
            output << sep << endl;
 
            try {
                __main(args);
            }
            catch (Exception* e) {
                errout << e->toStringAll() << endl;
                e->destroy();
            }
 
            DateTime finish = DateTime::getCurrentLocalTime();
            output << sep << endl
                << L"Finish [" << finish.toString()
                << L" " << (finish - start).toString()
                << L"]" << endl;
        }
#if __DCL_DEBUG
#if __DCL_HAVE_ALLOC_DEBUG
        DCLDebugDumpGlobalMemoryLeak(DCL_ALLOC_DUMP_ALL, &errout);
#endif
        DCLDebugSetGlobalReport(NULL);
#endif      // __DCL_DEBUG
    }
    __DCL_CLEANUP
 
    return 0;
}