Jalankan psql.exe dalam skrip python dan mengendalikan pengalihan I/O

Latar belakang dan cabaran masalah

Apabila melaksanakan alat baris perintah luaran dalam skrip python, tingkah laku yang tidak dijangka sering ditemui apabila arahan termasuk sintaks khusus shell seperti pengalihan I/O (seperti input membaca

 psql.exe postgresql: // user: pass@host: port/<sandaran><p> Pengguna mungkin mendapati bahawa melaksanakan arahan ini secara langsung pada baris arahan boleh berjaya mengimport penyataan SQL dalam fail sandaran.SQL ke dalam pangkalan data, tetapi dalam skrip Python, psql.exe baru bermula, tidak memproses rentetan sambungan, tidak membaca input dari Backup.sql, tetapi menunggu pengguna untuk memasuki secara manual.</p>
<p> Alasan masalah ini ialah modul subprocess Python tidak akan menghuraikan dan melaksanakan arahan melalui shell sistem secara lalai (iaitu shell = false). Ia melewati arahan dan parameter mereka terus ke sistem operasi. Ini bermakna rentetan seperti <sandaran.sql diproses oleh psql.exe sebagai parameter baris arahan biasa dan bukannya ditafsirkan input standard dari fail backup.sql sendiri tidak secara langsung menyokong bentuk pengalihan ini iaitu fungsi shell.><h3> Penyelesaian: Gunakan shell sistem untuk analisis arahan</h3>
<p> Untuk menyelesaikan masalah ini, idea teras adalah untuk membiarkan shell sistem bertanggungjawab untuk menghuraikan aksara khas dalam perintah, termasuk pengalihan I/O. Ini boleh dicapai melalui shell = parameter sebenar modul subprocess. Apabila shell = benar, subprocess melepasi keseluruhan arahan (atau rentetan arahan yang disambungkan dari senarai parameter) ke shell lalai sistem (contohnya, cmd.exe pada Windows, Bash atau ZSH pada Linux/MacOS) untuk dilaksanakan. Dengan cara ini, shell akan mentafsir dengan betul <simbol dan melengkapkan pengalihan kandungan fail.><p> Cara yang betul adalah membuat urutan (tuple atau senarai) dengan arahan, rentetan sambungan, dan simbol redirect dan laluan fail mereka sebagai elemen berasingan dan lulus mereka ke subprocess.check_call, dan tetapkan shell = benar. Apabila subprocess menerima urutan dengan shell = benar, ia akan menggabungkan unsur -unsurnya ke dalam rentetan arahan lengkap dengan ruang, dan kemudian menyerahkan rentetan ke shell untuk pelaksanaan.</p>
<p> Berikut adalah contoh kod khusus yang menunjukkan cara melaksanakan perintah psql.exe dengan betul dengan pengalihan I/O di Python:</p>
<pre class="brush:php;toolbar:false"> Import subprocess
Import OS

# --- Simulasi maklumat konfigurasi, sila gantikannya dengan sumber konfigurasi anda semasa menggunakannya ---
Konfigurasi Kelas:
    Log masuk = "Your_user"
    Kata Laluan = "Your_password"
    host = "localhost"
    port = "5432"
conf = config ()
# --- Maklumat konfigurasi simulasi berakhir ---

# Pastikan bahawa laluan fail psql.exe dan sql betul# jalan di sini adalah relatif kepada direktori induk skrip semasa. Sila menyesuaikannya mengikut situasi sebenar# Anggapkan bahawa psql.exe berada dalam direktori induk skrip semasa psql_commandlet = os.path.abspath (os.path.join (os.path.dirname (__ file__), "..", "psql.exe")
# Anggap sandaran.SQL berada dalam direktori induk skrip semasa sandaran_file_path = os.path.abspath (os.path.join (os.path.dirname (__ file__), "..", "backup.sql"))

# Bina PostgreSQL Sambungan String User = Conf.Login
kata laluan = conf.password
host = conf.host
port = conf.port
connection_string = f "postgresql: // {user}: {password}@{host}: {port}/your_database_name" # Ingatlah untuk menggantikan nama pangkalan data def run_psql_restore ():
    "" "
    Gunakan modul subprocess untuk melaksanakan perintah psql.exe dan proses pengalihan input fail.
    "" "
    cetak (f "cuba laksanakan perintah psql ke: {connection_string}")
    cetak (f "akan membaca input dari fail '{backup_file_path}'.")

    Cuba:
        Penyelesaian #Core:
        # 1. Letakkan arahan, rentetan sambungan, simbol redir, dan laluan fail ke dalam tupel sebagai elemen berasingan.
        # 2. Tetapkan shell = benar untuk membolehkan shell sistem menghuraikan simbol redirect '<p>Dalam kod di atas, subprocess.check_call ((psql_commandlet, connection_string, "</p><h3> Nota dan amalan terbaik untuk shell = benar</h3><p> Walaupun Shell = True menyediakan kemudahan untuk menyelesaikan masalah tersebut, perkara -perkara berikut mesti diberi perhatian apabila menggunakannya:</p><ol>
<li> <strong>Risiko Keselamatan:</strong> Shell = Benar membentangkan potensi risiko keselamatan, terutamanya apabila rentetan perintah atau mana -mana bahagiannya diperoleh daripada input pengguna yang tidak dipercayai. Pengguna yang berniat jahat boleh melakukan operasi yang tidak dibenarkan dengan menyuntik perintah shell tambahan. Sebagai contoh, jika BACKUP_FILE_PATH disediakan oleh pengguna dan belum disahkan dengan ketat, pengguna boleh memasukkan "malicious.sql; rm -rf /", yang boleh dilaksanakan dalam hal shell = benar. Oleh itu, adalah penting untuk mengesahkan dan membersihkan semua input luaran dengan ketat.</li>
<li> <strong>Perbezaan platform:</strong> Sistem operasi yang berbeza menggunakan kerang yang berbeza (Windows adalah cmd.exe, linux/macOS biasanya bash atau zsh, dll), dan sintaks perintah mereka mungkin halus. Apabila menggunakan shell = benar, anda perlu memastikan bahawa arahan boleh dilaksanakan dengan betul dalam shell pada sistem operasi sasaran.</li>
<li> <strong>Overhead Prestasi:</strong> Memulakan proses shell tambahan akan mengakibatkan sedikit overhead prestasi. Untuk arahan mudah yang memerlukan pelaksanaan yang kerap, jika anda tidak memerlukan fungsi shell khas, biasanya disyorkan untuk menggunakan shell = palsu.</li>
<li> <strong>Pengendalian ralat:</strong> subprocess.check_call akan membuang pengecualian yang dipanggil apabila arahan mengembalikan kod keluar bukan sifar, yang sangat berguna untuk menilai sama ada perintah itu berjaya. Untuk mendapatkan output yang lebih terperinci (output standard dan ralat standard), anda boleh menggunakan fungsi subprocess.run dan tetapkan capture_output = true dan teks = benar.</li>
</ol><h4> Alternatif (lebih selamat tetapi mungkin lebih kompleks)</h4><p> Untuk pengalihan input fail mudah, ia boleh dilakukan tanpa menggunakan shell = benar, yang biasanya lebih selamat:</p><pre class="brush:php;toolbar:false"> Import subprocess
Import OS

# Anggapkan bahawa psql_commandlet dan connection_string ditakrifkan# ... (sama seperti yang ditakrifkan dalam kod di atas) ...

DEF RUN_PSQL_RESTORE_SAFE ():
    cetak (f "cuba laksanakan arahan psql (mod selamat) ke: {connection_string}")
    cetak (f "akan membaca input dari fail '{backup_file_path}'.")

    Cuba:
        dengan terbuka (backup_file_path, 'r') sebagai sql_file:
            # Jangan gunakan shell = benar, lulus subprocess objek fail.check_call melalui parameter stdin (
                [psql_commandlet, connection_string], # command and parameter list stdin = sql_file # ambil objek fail sebagai input standard)
        Cetak ("\ npsql.exe perintah dilaksanakan dengan jayanya (mod selamat).")
    Kecuali subprocess.CalledProcessError sebagai E:
        cetak (f "\ nerror: pelaksanaan perintah psql.exe gagal, kod kembali: {e.returncode}")
    Kecuali FileNotFoundError:
        Cetak (f "\ nerror: fail psql.exe atau sql tidak dapat dijumpai.")
    Kecuali pengecualian sebagai e:
        cetak (f "\ nunknown ralat berlaku semasa pelaksanaan: {e}")

# jika __name__ == "__main__":
# # ... (simulasi penciptaan fail) ...
# run_psql_restore_safe ()

Kaedah ini secara langsung paip kandungan fail ke input standard psql.exe melalui stdin = sql_file, mengelakkan campur tangan shell dan dengan itu meningkatkan keselamatan. Walau bagaimanapun, pendekatan ini hanya sesuai untuk pengalihan input mudah. Untuk senario di mana fungsi shell yang lebih kompleks (seperti saluran paip, rantai arahan, tetapan pembolehubah persekitaran, dan lain -lain), shell = benar masih merupakan pilihan yang lebih langsung.

Meringkaskan

Memahami bagaimana modul subprocess berfungsi adalah penting apabila melaksanakan arahan luaran dalam skrip python dan pengendalian I/O mengalihkan (seperti