Forum |  HardWare.fr | News | Articles | PC | Prix | S'identifier | S'inscrire | Aide | Shop Recherche
652 connectés 

  FORUM HardWare.fr
  Programmation
  Shell/Batch

  [UNIX/KSH] Tester l'existence de tables ! Erreur louche ! - RESOLU -

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[UNIX/KSH] Tester l'existence de tables ! Erreur louche ! - RESOLU -

n°1992433
Kerrozen
To be or not to be ... cool ..
Posté le 12-05-2010 à 10:28:51  profilanswer
 

Bonjour à tous,  
 
Désolé à l'avance de la tartine, mais ayant peur de m'être perdu dans le code j'en mets un grand bout pour qu'on y voit plus clair....
 
Contexte : tester l'existence de tables, listées dans un fichier plat, sur deux schémas de la même instance ORACLE. On ne connaît pas le nombre de tables à l'avance bien sûr, sinon c'est pas drôle.
 
Suite à ces tests, construire un fichier SQL prêt à être passé pour effectuer une comparaison ligne à ligne des tables homonymes sur les deux schémas (la requête est bien lourde, oui je sais, mais je n'ai pas le choix pour cette requête de comparaison : moi ce qui me tracasse ce sont les tests d'existence des tables)
 
J'ai un souci qui est revenu plusieurs fois auparavant et que je n'arrive pas à m'expliquer : je fais deux tests SQL en passant les commandes via une redirection de l'entrée standard ( lignes avec << EOF et << EOF1 ) la première semble passer nickel, mais la deuxième plante avec le message d'erreur suivant :

Code :
  1. compare_liste_tables.ksh[157]: syntax error at line 187 : `<' unmatched


 
Si quelqu'un avaitune idée, ça me serait très utile, autant pour ma culture perso que pour mes pu**** de scripts !
 
Merci d'avance  :jap:  :jap:  :jap:  
 
Voilà le code avec quelques commentaires :
 

Code :
  1. #!/bin/ksh
  2. ########################################################################################################
  3. ##         SCRIPT DE COMPARAISON MULTI-TABLES A PARTIR DE FICHIER *.lst
  4. #####################################################################################################
  5. # Variables
  6. ############
  7. export script=$(basename ${0})
  8. export liste=""
  9. export instance=""
  10. export schema1=""
  11. export schema2=""
  12. export erreur=0
  13. export filelog=""
  14.  
  15. # Usage
  16. ########
  17. function usage
  18. {
  19.     echo " Usage : ${script} <instance> <schema1> <schema2> <liste_table>"
  20.     echo
  21.     echo "         <instance> = SSID Oracle du couloir"
  22.     echo "         <schema1> = schema source (OC0000, OC0001, OC9001....)"
  23.     echo "         <schema2> = schema cible (OC0000, OC0001, OC9001....)"
  24.     echo "         <liste_table> = fichier local contenant la liste de table a comparer ( ! extension = lst )"
  25. }
  26.  
  27. # Affichage d'une erreur + sortie 1
  28. ####################################
  29. function print_err
  30. {
  31.     clear
  32.     echo "\n ! ${1} !\n"
  33.     usage
  34.     exit 1
  35. }
  36.  
  37. # Affichage message d'information
  38. ##################################
  39. function print_info
  40. {
  41.     echo "\n `date '+%D %H:%M:%S'` ${script} : ${1}"
  42. }
  43.  
  44. #######
  45. # MAIN
  46. #######
  47. print_info "Tests des parametres et de la connexion"
  48. echo "[\c"
  49.  
  50. # Test du nombre de paramètres
  51. if [ ${#} -ne 4 ]
  52. then
  53.     print_err "Nombre de parametres incorrect"
  54. fi
  55. echo ".\c"
  56.  
  57. # Tests sur la liste de table
  58. if [ -r ${4} ]
  59. then
  60.        # Test de l extension        
  61.        if [ "`echo ${4} | awk -F. '{print $NF;}'`" != "lst" ]
  62.        then
  63.                print_err "Le fichier contenant la liste doit porter une extension '.lst'"
  64.        fi
  65. else
  66.     print_err "Le 4eme parametre doit etre un fichier portant l'extension .lst"
  67. fi
  68. liste=${4}
  69. echo ".\c"
  70.  
  71. # test de l'instance
  72. if [ `tnsping ${1} >&-;echo $?` -ne 0 ]
  73. then
  74.     print_err "L'instance <${1}> n'existe pas"
  75. fi
  76. instance=${1}
  77. echo ".\c"
  78.  
  79. # test du schéma 1
  80. sqlplus -S /nolog << EOF
  81. connect db_export/export@${instance}
  82. set feedback off
  83. set verify off
  84. set heading off
  85. whenever sqlerror exit 1
  86.  variable ret_val number
  87.  DECLARE
  88.  BEGIN
  89.  :ret_val := 0;
  90.  if ('${2}' not in ('SYSTEM','SYS')) then
  91.    if UTILS.DATAFOUND('DBA_USERS','USERNAME', '${2}') <> 1 then
  92.      :ret_val:=1;
  93.    END IF;
  94.  END IF;
  95.  END;
  96. /
  97. disconnect
  98. exit :ret_val;
  99. EOF
  100.  
  101. if [ "$?" != "0" ]
  102. then
  103.     print_err  "Le schema <${2}> n'existe pas dans l'instance ${1}"
  104. fi
  105. schema1=${2}
  106. echo ".\c"
  107.  
  108. # test du schéma 2
  109. sqlplus -S /nolog << EOF
  110. connect db_export/export@${instance}
  111. set feedback off
  112. set verify off
  113. set heading off
  114. whenever sqlerror exit 1
  115.  variable ret_val number
  116.  DECLARE
  117.  BEGIN
  118.  :ret_val := 0;
  119.  if ('${3}' not in ('SYSTEM','SYS')) then
  120.    if UTILS.DATAFOUND('DBA_USERS','USERNAME', '${3}') <> 1 then
  121.      :ret_val:=1;
  122.    END IF;
  123.  END IF;
  124.  END;
  125. /
  126. disconnect
  127. exit :ret_val;
  128. EOF
  129.  
  130. if [ "$?" != "0" ]
  131. then
  132.     print_err  "Le schema <${3}> n'existe pas dans l'instance ${1}"
  133. fi
  134. schema2=${3}
  135. echo ".] \c"
  136.  
  137. print_info "Tests OK"
  138.  
  139. # Creation fichier de logs et en tete
  140. filelog="./ISWO_comparaison_${instance}_${schema1}_${schema2}_`echo ${3} | awk -F. '{print $1;}'`_`date +%Y%m%d%H%M%S`.log"
  141. print_info "Fichier de log : <${filelog}>"
  142. echo "### Comparaison enter les schemas <${schema1}> et <${schema2}> sur l'instance ${instance} ###" >> ${filelog}
  143. echo "##################################################################################" >> ${filelog}
  144. echo >> ${filelog}
  145. print_info "Fichier contenant la liste des tables : <${liste}>" | tee -a ${filelog}
  146.  
  147. # Création du fichier SQL à passer
  148. for tab in $( cat ${liste})
  149. do
  150.     # test de la présence de la table sur les deux instances.
  151. sqlplus -S /nolog << EOF
  152. connect db_export/export@${instance}
  153. whenever sqlerror exit 1
  154. set verify off
  155. set serveroutput on
  156.    variable ret_val number
  157.    DECLARE
  158.      ma_var integer;
  159.    BEGIN
  160.      :ret_val := 0;
  161.      if ('${schema1}' not in ('SYSTEM','SYS')) then
  162.        select CASE WHEN EXISTS(SELECT TABLE_NAME,owner FROM DBA_TABLES WHERE owner='${schema1}' AND TABLE_NAME='${tab}' )THEN 1 ELSE 0 END INTO ma_var FROM dual;
  163.        IF ma_var <> 1 THEN
  164.           :ret_val:=1;
  165.        END IF ;
  166.      END IF;
  167.    END;
  168. /
  169. disconnect
  170. exit :ret_val;
  171. EOF
  172.  
  173.     if [ "$?" != "0" ]
  174.     then
  175.               print_info "La table <${tab}> n'existe pas sous le schema ${schema1}."
  176.               erreur=$((${erreur}+1))
  177.     else
  178. sqlplus -S /nolog << EOF1
  179. connect db_export/export@${instance}
  180. whenever sqlerror exit 1
  181. set verify off
  182. set serveroutput on
  183.    variable ret_val number
  184.    DECLARE
  185.      ma_var integer;
  186.    BEGIN
  187.      :ret_val := 0;
  188.      if ('${schem2}' not in ('SYSTEM','SYS')) then
  189.        select CASE WHEN EXISTS(SELECT TABLE_NAME,owner FROM DBA_TABLES WHERE owner='${schema2}' AND TABLE_NAME='${tab}' )THEN 1 ELSE 0 END INTO ma_var FROM dual;
  190.        IF ma_var <> 1 THEN
  191.           :ret_val:=1;
  192.        END IF ;
  193.      END IF;
  194.    END;
  195. /
  196. disconnect
  197. exit :ret_val;
  198. EOF1        
  199.         if [ "$?" != "0" ]
  200.         then
  201.                   print_info "La table <${tab}> n'existe pas sous le schema ${schema2}."
  202.                   erreur=$((${erreur}+1))
  203.         else
  204.             # Si ok Rajout des lignes pour la comparaison de cette table sur les deux schemas
  205.             echo "select * from" >> compare_tmp.sql
  206.             echo "(" >> compare_tmp.sql
  207.             echo "    select '${schema1}.${tab}' \"Row Source\", a.* from" >> compare_tmp.sql
  208.             echo "    (" >> compare_tmp.sql
  209.             echo "        select /*+ FULL(Tbl1)  */ *" >> compare_tmp.sql
  210.             echo "        from   ${schema1}.${tab} Tbl1" >> compare_tmp.sql
  211.             echo "        minus" >> compare_tmp.sql
  212.             echo "        select /*+ FULL(Tbl2)  */ *" >> compare_tmp.sql
  213.             echo "        from   ${schema2}.${tab} Tbl2" >> compare_tmp.sql
  214.             echo "    ) A" >> compare_tmp.sql
  215.             echo "    union all" >> compare_tmp.sql
  216.             echo "    select '${schema2}.${tab}', b.* from" >> compare_tmp.sql
  217.             echo "    (" >> compare_tmp.sql
  218.             echo "        select /*+ FULL(Tbl2)  */ *" >> compare_tmp.sql
  219.             echo "        from   ${schema2}.${tab}" >> compare_tmp.sql
  220.             echo "        minus" >> compare_tmp.sql
  221.             echo "        select /*+ FULL(Tbl1)  */ *" >> compare_tmp.sql
  222.             echo "        from   ${schema1}.${tab}" >> compare_tmp.sql
  223.             echo "    ) B" >> compare_tmp.sql
  224.             echo " )" >> compare_tmp.sql
  225.             echo "Order by 1 ;" >> compare_tmp.sql
  226.             echo "UNION" >> compare_tmp.sql
  227.         fi
  228.     fi
  229. done
  230.  
  231. if [ ${erreur} -ne 0 ]
  232. then
  233.     print_info "! Traitements KO : ${erreur} table(s) en erreur pendant la comparaison : voir les logs ci-dessus." | tee -a ${filelog}
  234.     rm compare_tmp.sql 2>&-
  235.     print_err "Traitements KO : erreur(s) dans la comparaison des tables. Voir le fichier de logs <${fic_res}>"
  236. fi
  237.  
  238. # Ajustement fichier de comptage
  239. sed '$d' compare_tmp.sql >> compare.sql
  240. echo ";" >> compare.sql
  241. rm compare_tmp.sql 2>&-
  242.  
  243.  
  244. print_info "### Traitement termines : OK ###" | tee -a ${filelog}
  245. exit 0

Message cité 1 fois
Message édité par Kerrozen le 12-05-2010 à 10:51:38

---------------
En programmation, quand t'as un problème et qu'il n'y a que deux solutions valides, seule la troisième fonctionne !
mood
Publicité
Posté le 12-05-2010 à 10:28:51  profilanswer
 

n°1992460
Kerrozen
To be or not to be ... cool ..
Posté le 12-05-2010 à 10:50:44  profilanswer
 

Bon, eh bien comme quoi ça aide de regarder son propre message : souvent on trouve le problème !
 
En fait lors de l'utilisation de la redirection de l'entrée standard, apparement on n'a pas le choix : il faut utiliser le mot clé 'EOF'
 
Là mon code plante avec le 'EOF1' lors du deuxième test d'existence de table, remplacé par 'EOF' ça passe !
 
Donc j'ai plus qu'à remercier mon moi-même et conseiller à mon premier moi de mieux se relire  :heink:  :??:  :ouch:  
 
En espérant que ça serve à quelqu'un d'autre.
 
See you soon !


---------------
En programmation, quand t'as un problème et qu'il n'y a que deux solutions valides, seule la troisième fonctionne !
n°1992920
Sve@r
Posté le 13-05-2010 à 21:38:18  profilanswer
 

Attention quand tu utilises des fichiers temporaires (style "compare_tmp.sql" ) car n'oublies pas que t'es en environnement multi-utilisateurs. A priori, rien n'interdit de lancer ton script plusieurs fois en parallèle. Mais il y aura grosse collision au niveau de ton fichier...
 
Déjà dans 80% des cas on peut éviter de créer un fichier temporaire. Mais si jamais on peut pas, alors toujours penser à lui mettre "$$" dans son nom. Ainsi, son nom sera associé au n° de pid qui est unique tant que le processus tourne.
Par ailleurs, t'as à ta disposition
/tmp
/var/tmp
$HOME/tmp
qui sont tous dédiés aux fichiers temporaires. Ca évitera de pourrir tous tes dossiers de fichiers résiduels inutiles...
 

Kerrozen a écrit :


Voilà le code avec quelques commentaires :
 

Code :
  1. #!/bin/ksh
  2. ########################################################################################################
  3. ##         SCRIPT DE COMPARAISON MULTI-TABLES A PARTIR DE FICHIER *.lst
  4. #####################################################################################################
  5. # Variables
  6. ############
  7. export script=$(basename ${0})
  8. export liste=""
  9. export instance=""
  10. export schema1=""
  11. export schema2=""
  12. export erreur=0
  13. export filelog=""



export n'est utile que si les variables exportées ont besoin d'être connues d'un script fils qui sera appelé par celui-là
Apparemment ton script n'en appelle pas d'autre donc pas besoin de charger la table d'export.
 

Kerrozen a écrit :

Code :
  1. # Usage
  2. ########
  3. function usage
  4. {
  5.     echo " Usage : ${script} <instance> <schema1> <schema2> <liste_table>"
  6.     echo
  7.     echo "         <instance> = SSID Oracle du couloir"
  8.     echo "         <schema1> = schema source (OC0000, OC0001, OC9001....)"
  9.     echo "         <schema2> = schema cible (OC0000, OC0001, OC9001....)"
  10.     echo "         <liste_table> = fichier local contenant la liste de table a comparer ( ! extension = lst )"
  11. }
  12.  
  13. # Affichage d'une erreur + sortie 1
  14. ####################################
  15. function print_err
  16. {
  17.     clear
  18.     echo "\n ! ${1} !\n"
  19.     usage
  20.     exit 1
  21. }
  22.  
  23. # Affichage message d'information
  24. ##################################
  25. function print_info
  26. {
  27.     echo "\n `date '+%D %H:%M:%S'` ${script} : ${1}"
  28. }
  29.  
  30. #######
  31. # MAIN
  32. #######
  33. print_info "Tests des parametres et de la connexion"
  34. echo "[\c"
  35.  
  36. # Test du nombre de paramètres
  37. if [ ${#} -ne 4 ]
  38. then
  39.     print_err "Nombre de parametres incorrect"
  40. fi
  41. echo ".\c"



Dommage de tester égal/pas égal à 4. A priori, il en faut au-moins 4 donc c'est pas grave si le gus en entre 150. Seuls les 4 premiers seront utilisés et pis voila.
 

Kerrozen a écrit :

Code :
  1. # Tests sur la liste de table
  2. if [ -r ${4} ]
  3. then
  4.        # Test de l extension        
  5.        if [ "`echo ${4} | awk -F. '{print $NF;}'`" != "lst" ]
  6.        then
  7.                print_err "Le fichier contenant la liste doit porter une extension '.lst'"
  8.        fi
  9. else
  10.     print_err "Le 4eme parametre doit etre un fichier portant l'extension .lst"
  11. fi
  12. liste=${4}
  13. echo ".\c"



Dommage d'appeler un aussi gros programme que awk pour extraire l'extension. echo $4 |cut -f2 -d. sera plus rapide...
 

Kerrozen a écrit :

Code :
  1. # test de l'instance
  2. if [ `tnsping ${1} >&-;echo $?` -ne 0 ]
  3. then
  4.     print_err "L'instance <${1}> n'existe pas"
  5. fi
  6. instance=${1}
  7. echo ".\c"
  8.  
  9. # test du schéma 1
  10. sqlplus -S /nolog << EOF
  11. connect db_export/export@${instance}
  12. set feedback off
  13. set verify off
  14. set heading off
  15. whenever sqlerror exit 1
  16.  variable ret_val number
  17.  DECLARE
  18.  BEGIN
  19.  :ret_val := 0;
  20.  if ('${2}' not in ('SYSTEM','SYS')) then
  21.    if UTILS.DATAFOUND('DBA_USERS','USERNAME', '${2}') <> 1 then
  22.      :ret_val:=1;
  23.    END IF;
  24.  END IF;
  25.  END;
  26. /
  27. disconnect
  28. exit :ret_val;
  29. EOF
  30.  
  31. if [ "$?" != "0" ]



$? est une variable numérique => [ $? -eq 0 ]
A priori, il n'y a aucune différence. Sauf que c'est plus propre d'utiliser les bons outils au bon endroit.
En plus, [ "$?" = "00" ] ne marche pas mais [ $? -eq 00 ] fonctionnera...

Kerrozen a écrit :

Code :
  1. then
  2.     print_err  "Le schema <${2}> n'existe pas dans l'instance ${1}"
  3. fi
  4. schema1=${2}
  5. echo ".\c"
  6.  
  7. # test du schéma 2
  8. sqlplus -S /nolog << EOF
  9. connect db_export/export@${instance}
  10. set feedback off
  11. set verify off
  12. set heading off
  13. whenever sqlerror exit 1
  14.  variable ret_val number
  15.  DECLARE
  16.  BEGIN
  17.  :ret_val := 0;
  18.  if ('${3}' not in ('SYSTEM','SYS')) then
  19.    if UTILS.DATAFOUND('DBA_USERS','USERNAME', '${3}') <> 1 then
  20.      :ret_val:=1;
  21.    END IF;
  22.  END IF;
  23.  END;
  24. /
  25. disconnect
  26. exit :ret_val;
  27. EOF
  28.  
  29. if [ "$?" != "0" ]
  30. then
  31.     print_err  "Le schema <${3}> n'existe pas dans l'instance ${1}"
  32. fi
  33. schema2=${3}
  34. echo ".] \c"
  35.  
  36. print_info "Tests OK"
  37.  
  38. # Creation fichier de logs et en tete
  39. filelog="./ISWO_comparaison_${instance}_${schema1}_${schema2}_`echo ${3} | awk -F. '{print $1;}'`_`date +%Y%m%d%H%M%S`.log"



T'aimes pas le cut toi hein ???
 

Kerrozen a écrit :

Code :
  1. print_info "Fichier de log : <${filelog}>"
  2. echo "### Comparaison enter les schemas <${schema1}> et <${schema2}> sur l'instance ${instance} ###" >> ${filelog}
  3. echo "##################################################################################" >> ${filelog}
  4. echo >> ${filelog}
  5. print_info "Fichier contenant la liste des tables : <${liste}>" | tee -a ${filelog}
  6.  
  7. # Création du fichier SQL à passer
  8. for tab in $( cat ${liste})
  9. do
  10.     # test de la présence de la table sur les deux instances.
  11. sqlplus -S /nolog << EOF
  12. connect db_export/export@${instance}
  13. whenever sqlerror exit 1
  14. set verify off
  15. set serveroutput on
  16.    variable ret_val number
  17.    DECLARE
  18.      ma_var integer;
  19.    BEGIN
  20.      :ret_val := 0;
  21.      if ('${schema1}' not in ('SYSTEM','SYS')) then
  22.        select CASE WHEN EXISTS(SELECT TABLE_NAME,owner FROM DBA_TABLES WHERE owner='${schema1}' AND TABLE_NAME='${tab}' )THEN 1 ELSE 0 END INTO ma_var FROM dual;
  23.        IF ma_var <> 1 THEN
  24.           :ret_val:=1;
  25.        END IF ;
  26.      END IF;
  27.    END;
  28. /
  29. disconnect
  30. exit :ret_val;
  31. EOF
  32.  
  33.     if [ "$?" != "0" ]
  34.     then
  35.               print_info "La table <${tab}> n'existe pas sous le schema ${schema1}."
  36.               erreur=$((${erreur}+1))
  37.     else
  38. sqlplus -S /nolog << EOF1
  39. connect db_export/export@${instance}
  40. whenever sqlerror exit 1
  41. set verify off
  42. set serveroutput on
  43.    variable ret_val number
  44.    DECLARE
  45.      ma_var integer;
  46.    BEGIN
  47.      :ret_val := 0;
  48.      if ('${schem2}' not in ('SYSTEM','SYS')) then
  49.        select CASE WHEN EXISTS(SELECT TABLE_NAME,owner FROM DBA_TABLES WHERE owner='${schema2}' AND TABLE_NAME='${tab}' )THEN 1 ELSE 0 END INTO ma_var FROM dual;
  50.        IF ma_var <> 1 THEN
  51.           :ret_val:=1;
  52.        END IF ;
  53.      END IF;
  54.    END;
  55. /
  56. disconnect
  57. exit :ret_val;
  58. EOF1        
  59.         if [ "$?" != "0" ]
  60.         then
  61.                   print_info "La table <${tab}> n'existe pas sous le schema ${schema2}."
  62.                   erreur=$((${erreur}+1))
  63.         else
  64.             # Si ok Rajout des lignes pour la comparaison de cette table sur les deux schemas
  65.             echo "select * from" >> compare_tmp.sql
  66.             echo "(" >> compare_tmp.sql
  67.             echo "    select '${schema1}.${tab}' \"Row Source\", a.* from" >> compare_tmp.sql
  68.             echo "    (" >> compare_tmp.sql
  69.             echo "        select /*+ FULL(Tbl1)  */ *" >> compare_tmp.sql
  70.             echo "        from   ${schema1}.${tab} Tbl1" >> compare_tmp.sql
  71.             echo "        minus" >> compare_tmp.sql
  72.             echo "        select /*+ FULL(Tbl2)  */ *" >> compare_tmp.sql
  73.             echo "        from   ${schema2}.${tab} Tbl2" >> compare_tmp.sql
  74.             echo "    ) A" >> compare_tmp.sql
  75.             echo "    union all" >> compare_tmp.sql
  76.             echo "    select '${schema2}.${tab}', b.* from" >> compare_tmp.sql
  77.             echo "    (" >> compare_tmp.sql
  78.             echo "        select /*+ FULL(Tbl2)  */ *" >> compare_tmp.sql
  79.             echo "        from   ${schema2}.${tab}" >> compare_tmp.sql
  80.             echo "        minus" >> compare_tmp.sql
  81.             echo "        select /*+ FULL(Tbl1)  */ *" >> compare_tmp.sql
  82.             echo "        from   ${schema1}.${tab}" >> compare_tmp.sql
  83.             echo "    ) B" >> compare_tmp.sql
  84.             echo " )" >> compare_tmp.sql
  85.             echo "Order by 1 ;" >> compare_tmp.sql
  86.             echo "UNION" >> compare_tmp.sql



Ouch tous ces echo redirigés !!!
T'as quand-même des outils plus sympa pour ce genre de truc
Exemple 1

Code :
  1. (
  2.    echo truc
  3.    echo truc 2
  4.    echo truc 3
  5. ) > compare_tmp.sql


 
Exemple 2

Code :
  1. cat << _EOT_ > compare_tmp.sql
  2. truc
  3. truc1
  4. truc2
  5. _EOT_


 

Kerrozen a écrit :

Code :
  1. fi
  2.     fi
  3. done
  4.  
  5. if [ ${erreur} -ne 0 ]
  6. then
  7.     print_info "! Traitements KO : ${erreur} table(s) en erreur pendant la comparaison : voir les logs ci-dessus." | tee -a ${filelog}
  8.     rm compare_tmp.sql 2>&-
  9.     print_err "Traitements KO : erreur(s) dans la comparaison des tables. Voir le fichier de logs <${fic_res}>"
  10. fi
  11.  
  12. #
  13. # Ajustement fichier de comptage
  14. #
  15. sed '$d' compare_tmp.sql >> compare.sql
  16. echo ";" >> compare.sql
  17. rm compare_tmp.sql 2>&-



Dommage d'avoir créé un fichier "compare_tmp.sql" pour le recopier en final dans "compare.sql"
 
Exemple qui évite deux fichiers là où un seul suffirait...

Code :
  1. ...
  2. ... création et remplissage du fichier compare.sql ...
  3. ...
  4. echo ";" >> compare.sql     # Le point-virgule final
  5.  
  6. # Filtre de "compare.sql" dans lui-même
  7. exec 3<compare.sql
  8. rm -f compare.sql
  9. sed '$d' 0<&3 >compare.sql
  10. # Et voilà - En créant un canal associé à "compare.sql", on peut le supprimer il reste en mémoire. Ensuite il n'y a plus qu'à lire le canal 3 et le rediriger dans... compare.sql


 

Kerrozen a écrit :

Code :
  1. print_info "### Traitement termines : OK ###" | tee -a ${filelog}
  2. exit 0



Message édité par Sve@r le 13-05-2010 à 22:01:45

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Shell/Batch

  [UNIX/KSH] Tester l'existence de tables ! Erreur louche ! - RESOLU -

 

Sujets relatifs
Erreur lors de l'envoie d'un formulaire par mailrequete sur plusieurs bases [resolu]
[Résolu] Problème getElementById IE8 et safaritester la connexion entre deux poste
(resolu) Interview Analyste Programmeur[RESOLU] Mes liens ne fonctionnent plus
[Résolu] Connexion à une BDD en local ET à distance[Résolu] bash - grep et expressions régulières
Plus de sujets relatifs à : [UNIX/KSH] Tester l'existence de tables ! Erreur louche ! - RESOLU -


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite) / Groupe LDLC / Shop HFR