Пример #1
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")
Пример #2
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())
Пример #3
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))
Пример #4
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)