The key to performance is reading the huge file only once.

You can pass multiple patterns to grep by putting them on separate lines. This is usually done by telling grep to read patterns from a file:

grep -F -f 300KFile 30MFile

This outputs the matches in the order of the large file, and prints lines that match multiple patterns only once. Furthermore, this looks for patterns anywhere in the line; for example, if the pattern file contains 1234, then lines such as 123456,345678,2348962342 and 478912,1211138,1234 will match.

You can restrict to exact column matches by preprocessing the pattern. For example, if the patterns do not contain any special character ()?*+\|[]{}:

<300KFile sed -e 's/^/(^|,)/' -e 's/$/($|,)/' |
grep -E -f - 30MFile

If retaining only the first match for each pattern is important, make a first pass to extract only the relevant lines as above, then do a second pass in awk or perl that tracks patterns that have already been seen.

<300KFile sed -e 's/^/(^|,)/' -e 's/$/($|,)/' |
grep -E -f - 30MFile |
perl -l -F, -ape '
    BEGIN {
        open P, "300KFile" or die;
        %patterns = map {chomp; $_=>1} <P>;
        close P;
    }
    foreach $c (@F) {
        if ($patterns{$c}) {
            print;
            delete $patterns{$c};
        }
    }
'

GNU sed way

In GNU sed (if you are using some Linux distribution it should be default sed implementation), you can use something like this:

sed '/.production =/,+12d' inputfile.txt

How it works:

1. It scans the input file line by line (this is how sed works) and check if the command should be used.
2. Our command is d (the last character) which means delete the line.
3. But this command will only run if current line does match our range.
4. The range is specified by two arguments (start and end of range, inclusive) delimited by , character. First is a regular expression /.production =/ which match each line containing this expression. Second argument is +12d which means 12 lines from start range.
5. So our range matches each line that matches expression and next 12 lines and deletes them.
6. All the other lines are printed to the output (default sed behaviour).

Portable, ugly way

This one should work on other sed implementation but involves much more typing and is not so robust:

sed '/.production =/{N;N;N;N;N;N;N;N;N;N;N;N;d}' somefile.txt

How it works:

1. It scans the input file line by line (this is how sed works) and check if the command should be used.
2. It checks if the line matches the /.production =/ pattern. If so, it runs all the commands in {} braces.
3. We run N comamnd 12 times. N command reads next line and appends it to current buffer. So after we run it 12 times, we have 13 lines concatenated in current buffer (first line + 12 read by N commands).
4. Now we run d command which deletes this concatenated 13 lines.
5. sed continues until it finds another pattern and again deletes 13 lines. All the other lines are printed (default sed behaviour).