Você pode usar ALTER VIEW em conjunto com o esquema de informações . Você mencionou despejá-lo em um arquivo de texto, então talvez algo assim:

SELECT CONCAT("ALTER DEFINER=`youruser`@`host` VIEW `",table_name,"` AS ", view_definition,";") 
FROM information_schema.views WHERE table_schema='databasename'

Misture isso com a linha de comando mysql (assumindo * nix, não familiarizado com o Windows):

> echo "*abovequery*" | mysql -uuser -p > alterView.sql
> mysql -uuser -p databasename < alterView.sql

Nota lateral: Você não pode alterar as entradas information_schema diretamente . Nota2: Isso funciona para apenas um banco de dados por vez, se você deixar WHERE table_schema você precisa inserir comandos USE entre cada um.

Crie um arquivo de texto com todas as definições de visualização:

mysql -uusername -ppassword -A --skip-column-names -e"SELECT CONCAT('SHOW CREATE VIEW ',table_schema,'.',table_name,'\\G') FROM information_schema.tables WHERE engine IS NULL" | mysql -uusername -ppassword -A --skip-column-names > AllMyViews.sql

Você edita AllMyViews.sql a partir daí. Em seguida, solte as visualizações

mysql -uusername -ppassword -A --skip-column-names -e"SELECT CONCAT('DROP VIEW ',table_schema,'.',table_name,';') FROM information_schema.tables WHERE engine IS NULL" | mysql -uusername -ppassword -A

Depois de editar AllMyViews.sql, recarregue-os

mysql -uusername -ppassword -A < AllMyViews.sql

De uma chance !!!

Automatizando na solução do Derek, isso mudará o DEFINER para root@localhoste definirá SQL SECURITY INVOKER(certifique-se de que deseja isso primeiro!) em todas as visualizações em todos os bancos de dados:

mysql -BNe 'show databases' | \
egrep -v '^(information_schema|performance_schema)$' | \
while read DB
do 
    mysql -BNe "SELECT CONCAT(\"ALTER DEFINER=\`root\`@\`localhost\` SQL SECURITY INVOKER VIEW \",table_name,\" AS \", view_definition,\";\") FROM information_schema.views WHERE table_schema=\"$DB\"" | \
    mysql $DB
done

AVISO: certifique-se de ter feito um backup completo do mysql (por exemplo, parando o mysqld e fazendo backup de todos os arquivos em /var/lib/mysql) antes de executá-lo - apenas no caso ... Funcionou para mim, mas YMMV .

você também deve verificar todas as suas tabelas/visualizações com:

mysql -BNe 'show databases' | \
egrep -v '^(information_schema|performance_schema)$' | \
while read DB
do 
   mysql -BNe 'show tables' $DB | \
   while read t
   do
      echo "check table $t;"
   done | mysql -BN $DB
done | \
egrep -v 'status\s*OK'

ele não deve mais reclamar de definidores inválidos nas visualizações.

Exporte todas as visualizações do banco de dados <DB>:

mysql -BNe "SELECT TABLE_NAME FROM TABLES WHERE TABLE_SCHEMA = '<DB>' AND TABLE_TYPE = 'VIEW'" \
    information_schema | xargs mysqldump --single-transaction --no-data <DB> >views.sql

ou:

mysql -BNe "SELECT TABLE_NAME FROM VIEWS WHERE TABLE_SCHEMA = '<DB>'" \
    information_schema | xargs mysqldump --single-transaction --no-data <DB> >views.sql

Edite views.sql(altere o definidor) e recrie-os:

cat views.sql | mysql <DB>

Especifique -ue -palterne se necessário.

Eu criei um script python simples que substitui o definidor de banco de dados de produção pelo definidor de banco de dados local. Este script modificará os arquivos de despejo e importará automaticamente os bancos de dados especificados.

Repo GIT: https://github.com/mjakal/db-auto-import

import getpass
import os
import time

# Dump file path - here you can set your own path 
dump_path = "./dumps/"
# Set the list of dump file names to import
dump_files = ["testing.sql"]
# Set the list of definer names (inside dump file) you want to replace with your local db definer
dump_definers = ["DEFINER=`prod`@`some-host.com`"]

# MySQL local root username
db_root_user = "root"
# Set db names for each dump file - this must be in correct order
db_names = ["testing"]

# Local db user info
db_user = "testing"
db_password = "testing"
db_host = "localhost"

# Generate definer name from local db config - desired definer
# You can hard-code this value if you wish 
local_definer = f"DEFINER=`{db_user}`@`{db_host}`"

# ------------------------------------------------------------------------------
# You are all set - Leave the rest of the code as it is
# ------------------------------------------------------------------------------

# SQL connection config
mysql_config = f"mysql -u {db_root_user}"


def fix_dump_definer(dump_file):
    dump_file_path = dump_path + dump_file

    print("Fixing dump file:", dump_file)

    # Read file
    with open(dump_file_path, "rb") as file:
        file_data = file.read()

    # Replace the target string bytes
    for dump_definer in dump_definers:
        file_data = file_data.replace(dump_definer.encode(), local_definer.encode())

    # Write the file out again
    with open(dump_file_path, "wb") as file:
        file.write(file_data)

    print("Fixing dump file done:", dump_file)


def create_db(db_name):
    drop_db = f"DROP DATABASE IF EXISTS {db_name};"
    recreate_db = f"CREATE DATABASE {db_name} CHARACTER SET utf8 COLLATE utf8_general_ci;"
    # default mysql
    grant_db_permissions = f"GRANT ALL PRIVILEGES ON {db_name}.* TO {db_user}@{db_host} IDENTIFIED BY {db_password};"
    # percona specific
    # grant_db_permissions = f"GRANT ALL PRIVILEGES ON {db_name}.* TO {db_user}@{db_host};"
    flush_db_privileges = "FLUSH PRIVILEGES;"

    recreate_db_queries = f'{mysql_config} -e "{drop_db}{recreate_db}{grant_db_permissions}{flush_db_privileges}"'

    print("Creating database:", db_name)

    os.system(recreate_db_queries)

    print("Await MySQL restart")

    time.sleep(10)

    print("Creating database done:", db_name)


def import_db(db_name, dump_file):
    # Set dump file path
    dump_file_path = f"{dump_path}{dump_file}"

    print("Importing db:", db_name)

    import_db = f"{mysql_config} {db_name} < {dump_file_path}"

    os.system(import_db)

    time.sleep(5)

    print("Import done:", db_name)


def manage_db_import(db_name, dump_file):
    fix_dump_definer(dump_file)
    create_db(db_name)
    import_db(db_name, dump_file)


def main_script():
    try:
        print("--------------------------------------------------------------------------------")
        print("WARNING - This script is used for development purposes only.")
        print("Please don't try roning it on production environment!")
        print("--------------------------------------------------------------------------------")

        # Get db_names and dump_files list length
        db_count = len(db_names)
        dump_count = len(dump_files)

        # Check if lists have the same length
        if db_count != dump_count:
            return "db_names and dump_files must have the same length."

        # e.g. db_count = 11 result will be 100 - 1
        import_all_option = (10 ** ((db_count // 10) + 1)) - 1

        print("Please select one of the options below:")

        for index, dump_file in enumerate(dump_files):
            db_name = db_names[index]

            print(f"{index} - Import {db_name}")

        print(f"{import_all_option} - Import all databases")
        print(f"{import_all_option + 1} - Exit script")

        selected_option = int(input("Select option: "))

        # Exit the script
        if selected_option == import_all_option + 1:
            return "Exiting script."

        # Input MySQL root password
        db_root_password = getpass.getpass(prompt="Enter MySQL root password: ", stream=None)

        # If password exists, modify mysql_config global variable
        if db_root_password:
            global mysql_config
            mysql_config = f"{mysql_config} -p{db_root_password}"

        print("If you continue with this operation existing database(s) will be deleted.")
        continue_import = input("Would you like to continue (y/n)? ")

        if continue_import != "y":
            return "Exiting script."

        if selected_option == import_all_option:
            print("Importing all databases please wait...")

            for index, dump_file in enumerate(dump_files):
                db_name = db_names[index]

                manage_db_import(db_name, dump_file)
        elif selected_option in range(0, db_count):
            db_name = db_names[selected_option]
            dump_file = dump_files[selected_option]

            print(f"Importing {db_name} please wait...")

            manage_db_import(db_name, dump_file)
        else:
            return "Invalid input, exiting script."

        return "DB import finished."
    except Exception as ex:
        print(str(ex))
        return "Something went wrong, exiting script."


# Call the main function
main_script_output = main_script()

print(main_script_output)

Script de importação automática de banco de dados

Este script resolve o problema do definidor de usuário ao importar bancos de dados de um servidor sql para outro (por exemplo, servidor de produção para servidor de desenvolvimento local). Ele modifica a entrada do definidor do usuário em todas as visualizações/procedimentos armazenados dentro dos arquivos de despejo sql. Depois de modificar o definidor, ele importará automaticamente os bancos de dados especificados.

Requisitos

• SO - Linux/MacOS
• Python >= 3,6
• MySQL, MariaDB ou Percona

NOTA - Se você estiver usando Percona, comente a linha 58 e descomente a linha 60

# default mysql
# grant_db_permissions = f"GRANT ALL PRIVILEGES ON {db_name}.* TO {db_user}@{db_host} IDENTIFIED BY {db_password};"
# percona specific
grant_db_permissions = f"GRANT ALL PRIVILEGES ON {db_name}.* TO {db_user}@{db_host};"

Configuração

Abra o script db_auto_import.py em seu editor de texto favorito e edite as linhas abaixo.

# Dump file path - here you can set your own path 
dump_path = "./dumps/"
# Set the list of dump file names to import
dump_files = ["testing.sql"]
# Set the list of definer names (inside dump file) you want to replace with your local db definer
dump_definers = ["DEFINER=`prod`@`some-host.com`"]

# MySQL local root username
db_root_user = "root"
# Set db names for each dump file - this must be in correct order
db_names = ["testing"]

# Local db user info
db_user = "testing"
db_password = "testing"
db_host = "localhost"

Como executar o script

Primeiro, precisamos copiar/colar todos os arquivos de despejo de produção na pasta /dumps/. Os nomes dos arquivos de despejo devem corresponder aos nomes especificados na lista dump_files. Verifique sua configuração e execute o comando abaixo.

python db_auto_import.py

solução:

1. no phpmyadmin vá em "database_name" clique nas opções do menu de alternância acima dos gatilhos.
2. procure a respectiva tabela da qual você deseja alterar o definidor.
3. vá para a opção de edição e, em seguida, role para baixo até a opção de definição abaixo.
4. mude o definidor para "o que você quiser".