Exemple #1
0
    def execute(self):
        """The main method that splits the arguments and starts the magic"""
        left, right = self.left, self.right

        lcon = Source.connection(left)
        if not lcon:
            raise UnknownConnectionException(left.uri)
        lopts = left.get(lcon.dbms)
        rcon = Source.connection(right)
        if not rcon:
            raise UnknownConnectionException(right.uri)
        ropts = right.get(rcon.dbms)

        try:
            lcon.connect(lopts.database)
            rcon.connect(ropts.database)
            ltables = lcon.tables()
            if lopts.table not in ltables:
                raise UnknownTableException(lopts.table, ltables.keys())
            ltable = ltables[lopts.table]
            rtables = rcon.tables()
            if ropts.table not in rtables:
                raise UnknownTableException(ropts.table, rtables.keys())
            rtable = rtables[ropts.table]

            lcols = map(
                column_ddl if left.compare_ddl else column_name,
                ltable.columns())
            rcols = map(
                column_ddl if right.compare_ddl else column_name,
                rtable.columns())

            lplus = dict(map(
                lambda c: (c.split()[0], ltable.column(c.split()[0])),
                list(set(lcols) - set(rcols))))
            rplus = dict(map(
                lambda c: (c.split()[0], rtable.column(c.split()[0])),
                list(set(rcols) - set(lcols))))

            r = {}
            for k, v in lplus.iteritems():
                if k in rplus:
                    r[k] = (v, rplus[k])
                else:
                    r[k] = (v, None)
            for k, v in rplus.iteritems():
                if k not in lplus:
                    r[k] = (None, v)

            return to_dto(map(lambda (k, v): v, r.iteritems()))
        finally:
            lcon.close()
            rcon.close()
Exemple #2
0
    def execute(self):
        """The main method that splits the arguments and starts the magic"""
        options = self.options

        # search exact match of connection
        connection, opts = find_connection(
            Source.connections(),
            options,
            lambda con, opts: (
                (opts.show == "values" or opts.show == "columns" and opts.filter is not None) and con.matches(opts)
            ),
        )

        if connection is None:
            raise UnknownConnectionException(options.uri)

        try:
            connection.connect(opts.database)
            tables = connection.tables()
            if opts.table not in tables:
                raise UnknownTableException(opts.table, tables.keys())
            table = tables[opts.table]
            items = create_items(
                connection,
                connection.rows(table, opts.filter, opts.limit, simplify=False),
                opts.include,
                opts.exclude,
                opts.substitutes,
            )
            # remove duplicates
            return list(OrderedDict.fromkeys(items))
        finally:
            connection.close()

        raise Exception("Specify the complete URI to a table")
Exemple #3
0
    def build(self, options):
        cons = Source.connections()

        # search exact match of connection
        connection, opts = find_connection(
            cons, options, lambda con, opts: (opts.show != "connections" and con.matches(opts))
        )

        if connection is not None:
            return create(connection, opts)

        # print all connections
        return sorted([c for c in cons if c.filter_(options)], key=lambda c: c.title().lower())
Exemple #4
0
    def execute(self):
        options = self.options

        cons = Source.connections()

        # search exact match of connection
        for connection in cons:
            opts = options.get(connection.dbms)
            if opts.show_code > 1 and connection.matches(opts):
                try:
                    connection.connect(opts.database)
                    return to_dto(map(
                        RowItem, opts.statement_activity(connection)))
                finally:
                    connection.close()

        raise Exception('Specify the complete URI of the connection')
Exemple #5
0
    def execute(self):
        """The main method that splits the arguments and starts the magic"""
        options = self.options

        # search exact match of connection
        connection, opts = find_connection(
            Source.connections(),
            options,
            lambda con, opts: con.matches(opts))

        if connection is None:
            raise UnknownConnectionException(options.uri)

        if opts.show not in ['tables', 'columns', 'values']:
            raise Exception('Specify the complete URI to a table')

        return to_dto(self.build(connection, opts))
 def __init__(self, driver, file_, scheme, con_creator):
     Source.__init__(self)
     self.driver = driver
     self.file = file_
     self.scheme = scheme
     self.con_creator = con_creator
Exemple #7
0
 def __init__(self, uri, file_, key, con_creator):
     Source.__init__(self)
     self.uri = uri
     self.file = file_
     self.key = key
     self.con_creator = con_creator
Exemple #8
0
    def execute(self):
        """The main method that splits the arguments and starts the magic"""
        options = self.options

        # search exact match of connection
        connection, opts = find_connection(
            Source.connections(),
            options,
            lambda con, opts: (
                con.matches(opts)
                and opts.show in ['databases', 'tables', 'columns', 'values']))

        if connection is None:
            raise UnknownConnectionException(options.uri)

        # Reads the statements
        stmts = read_statements(opts)

        # Exit gracefully when no statements have been found (or the
        # input got cancelled)
        if not stmts:
            return []

        # Collects results
        results = []
        # Counts the changes (inserts, updates)
        changes = 0
        # Counts the errors (useful with option --ignore-errors)
        errors = 0
        # Counts the statements
        counter = 0

        timer = None
        executer = None
        try:
            # Connects to the database and starts a transaction
            connection.connect(opts.database)

            timer = LogTimer(logger, 'Executing SQL statements')

            if opts.isolate_statements:
                executer = IsolationExecuter(connection, opts)
            else:
                executer = DefaultExecuter(connection, opts)

            executer.begin()

            for stmt in stmts:
                start = datetime.now()
                sys.stdout.write(
                    EXECUTION_START.get(opts.verbose, '').format(
                        time=start,
                        statement=stmt))

                res, changed, failed = executer.execute(stmt)
                results.extend(res)
                changes += changed
                errors += failed
                counter += 1

                if (opts.progress > 0 and counter % opts.progress == 0):
                    sys.stderr.write('.')
                    sys.stderr.flush()

                end = datetime.now()
                sys.stdout.write(
                    EXECUTION_END.get(opts.verbose, '').format(
                        time=end,
                        statement=trim_space(stmt),
                        duration=(end - start).total_seconds()))

            if opts.dry_run:
                executer.rollback()
            else:
                executer.commit()

            if opts.progress > 0 and counter >= opts.progress:
                # Write a new line after progress indicator dots have
                # been written
                sys.stderr.write('\n')
        except BaseException:
            errors += 1
            if executer:
                executer.rollback()
            if not opts.mute_errors:
                raise
        finally:
            connection.close()
            if timer:
                timer.stop()

        if not results:
            dry_run = ''
            if opts.dry_run:
                dry_run = ' (dry run)'
            sys.stdout.write(
                'Changed rows: {0}{1}\n'.format(changes, dry_run))
        if errors:
            sys.stdout.write('Errors: {0}'.format(errors))

        return to_dto(results)