UNIX for Dummies Questions & Answers

Just to verify, your two files will always have the same number of lines? If not, there is no way to make the comparison.

Hi.
My impression is that this is a row-to-row comparison, so that if you run out of rows (lines) on either file prematurely, you just stop. It's not like diff, where one seeks back and forth vertically to see what was added, deleted, or changed.

Do you see it differently? [pun intended] ... cheers, drl

I'm just trying to verify that the original poster has thought the problem through. Your code will work correctly for the stated problem. But, if there are additions or deletions along with his updates, and the additions are not at the end of the file2, then he's back to a manual process of trying to figure out what changed between the files. In most situations, there is a key field to match on. But that doesn't seem to be the case here.

hey DRL thanks a ton!! for your help ..
but again as per the requirement of boss it has to be done using Unix shell script ( plsql if required)

the files file1 and file2 won't necessarily have the same number of rows .
file1 and file2 have column values of a specific oracle table exported and stored in Unix system on regular basis .
the idea is two compare the contents of the files of previous day and current day ( for e.g file1 is previous day's file and file2 is current day's file) i.e. we got to do row wise comparison of file and detect if there is change in any particular row value if any particular row in file2 (say for e.g row number 3 ) differs from row number 3 of file1 ... then the script should pick up the row num 3 value from file 2 and re-direct it to another third file.

but since we got to verify previous day's and current day's records .. so even if both the files do not have same number of lines ... it won't be a problem as our target is to compare whether a particular row which had some value until yesterday still has the same value today or has it been changed.. in such case the script can compare until it reaches the row end of file1 .
hope i m clear with my question

well i came across options ( thanks to this forum) but following code i tried
comp1=$(cat file1 | cut -d"|" -f1,2)
comp2=$(cat file2 | cut -d"|" -f1,2)
for str in ${comp2[*]}
do
count=0
while (( $count < ${#comp1[*]} ))
do
if [[ $str != ${comp1[count]} ]]
then

cat file2 | grep $str >> find.txt
fi
count=`expr $count+1`
done
done

Note:
file1
1111|universe
2222|good
3333|good
4444|good

file2
1111|universe
3333|universe
2222|good
4444|good

and in output i should get


3333|universe
2222|good

as row 2 and 3 of file2 are different from file1 so these 2 lines would be picked up from file2

i am not getting desired result
any suggestion how can the code be modified

try this,

Code:

perl -e ' open(FILE, "<", "f1"); while(<FILE>) { $fileHash{$_} = $. ; } close(FILE); open(FILE, "<", "f2"); while(<FILE>) { print $_ if ( $fileHash{$_} != $. ); } close(FILE); '

You didn't tell us which shell you are using. I don't know if your construction works in bash, but in ksh it won't:

typeset -A comp1=$(cat file1 | cut -d"|" -f2)

will produce an array with exactly one element from your files, as "typeset -A" uses whitespace as delimiter, not newlines. You will see that when you trace the script with "set -xv" and watch the output of "(cat file1 | cut ...)".

Then there is a logical error in your code: the "for str in .... done" cycles through every element of the array comp2[]. You compare each to every element of comp1[]: comp2[1] to comp1[1], then comp2[1] to comp1[2], ..., comp2[1] to comp1[n], comp2[2] to comp1[1], comp2[2] to comp1[2], ... This is probably not what you want to achieve - you want to compare comp1[1] to comp2[1], comp1[2] to comp2[2], etc. This is done by the following (demo-)code:

Code:

(( count = 0 ))
while (( count < ${#comp2[*]} )) ; do
     if [ "${comp2[$count]}" != "${comp1[$count]}" ] ; then
          print - "line $count is different"
     else
          print - "line $count is equal"
     fi
     (( count += 1 ))
done

If you want to *search* in one file for the key you found in the other and don't rely on them being sorted according to the same key then do the following: cycle through one array, searching through the other one. If you find a corresponding value store the number of the array-element found. If this number is not stored you have not found a corresponding element. Again, in a sketchy demo-code:

Code:

(( count1 = 0 ))
(( count2 = 0 ))
(( found = -1 ))
while (( count2 < ${#comp2[*]} )) ; do
     (( count1 = 0 ))
     (( found = -1 ))
     while (( count1 < ${#comp1[*]} )) ; do
          if [ "${comp2[$count2]}" != "${comp1[$count1]}" ] ; then
               (( found = count1 ))
          fi
          (( count1 += 1 ))
     done
     if [[ $found -lt 0 ]] ; then
          print - "no corresponding element to ${comp2[$count2]} found"
     else
          print - "element ${comp2[$count2]} corresponds to ${comp1[$found]}"
     fi
     (( count2 += 1 ))
done

bakunin