Python user input inside infinite loop too slow, easily confused

Don't build SQL strings from user input. Ever.

Always use parameterized queries.

# Adds an item to queue
def recordScan(isbn, shop_id):
    insert = "INSERT INTO scans ( isbn, shop_id ) VALUES ( ?, ? )"
    conn = connect()
    conn.cursor().execute(insert, [isbn, shop_id])
    conn.commit()
    conn.close()

Please read https://docs.python.org/2/library/sqlite3.html, at the very least the upper part of the page, where they explain this approach.

You appear to be opening and closing the database each and every time. That will clearly add a huge overhead, especially as you are "hammering" away at it.
Connect to the database once at the beginning and close it upon exit.
In between, simply perform your insert, update and delete statements.

Edit:
For the purposes of this I renamed db.py to be called barcode1.py so edit appropriately. Alter listen.py to be as follows:

#!/usr/bin/env python

import logging
import barcode1
DB_FILE_NAME = "scan-queue.db"
my_db = barcode1.sqlite3.connect(DB_FILE_NAME)
my_cursor = my_db.cursor()

def InsertScan(isbn, shop_id):
    insert = "INSERT INTO scans ( isbn, shop_id ) VALUES ( ?, ? )"
    my_cursor.execute(insert, [isbn, shop_id])
    my_db.commit()

while True:
    barcode = raw_input("Scan ISBN: ")
    if ( len(barcode) > 1 ):
        logging.info("Recording scanned ISBN: " + barcode)
        print "Recording scanned ISBN: " + barcode
        InsertScan(barcode, 1)
my_db.close()

For your purposes replace references to "barcode1" with "db"
As you can see all that happens here is that a separate function has been added to do the writing and only the writing.
Clearly this is a quick mock up and could be improved immeasurably, in fact I'd rewrite it as a single script. This is one of those classic examples where in an attempt to write object oriented code, you end up shooting yourself in the foot.
In fact you could do without the function and just include the insert code within the while statement.

Locking: from the sqlite3 documents:

 sqlite3.connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri])

Opens a connection to the SQLite database file database. You can use ":memory:" to open a database connection to a database that resides in RAM instead of on disk.

When a database is accessed by multiple connections, and one of the processes modifies the database, the SQLite database is locked until that transaction is committed. The timeout parameter specifies how long the connection should wait for the lock to go away until raising an exception. The default for the timeout parameter is 5.0 (five seconds).

After much experimenting based on helpful advice from users @tomalak, @rolf-of-saxony and @hevlastka my conclusion is that yes, this is an inevitability that I just have to live with.

Even if you strip the example down to the basics by removing the database write process and making it a simple parrot script that just repeats back inputs (See Python on Raspberry Pi user input inside infinite loop misses inputs when hit with many), it is still possible to scan items so fast that inputs get missed/skipped/ignored. The Raspberry Pi simply cannot keep up.

So my approach will now be to add an audio feedback feature such as a beep sound to indicate to the user when the device is ready to receive the next input. A route I didn't want to go down but it seems my code is the most efficient it can be and we're still able to hit the limits. Responsibility is with the user to not go at breakneck speed and the best we can do a responsible product builders is give them good feedback.

In addition to the issues I brought up in my first answer, there is another problem which effects the speed of the updates, namely the commits.
You will find that if you commit in batches, the speed goes up exponentially. Adjust the journaling and up it goes again.
Working on a PI 3, I mocked up 5000 updates in 10 seconds with the journal on and in 0.43 seconds with the journal off.
If you change your code to store the barcodes in a list and then fire off the database updates in batches, you code will work on a Raspberry Pi.

See below for my test code:

#!/usr/bin/env python
import sqlite3
import time
DB_FILE_NAME = "scan-queue.db"
my_db = sqlite3.connect(DB_FILE_NAME)
my_cursor = my_db.cursor()
my_cursor.execute('CREATE TABLE if not exists scans(id INTEGER PRIMARY KEY AUTOINCREMENT,isbn TEXT NOT NULL,shop_id INT NOT NULL)')   
my_db.commit()
#This line turns off journaling, passing off the writes to the OS
# No rollbacks are available and corruption can occur if the machine has an issue
# but you're not NASA
my_cursor.execute("PRAGMA synchronous = OFF") #Can increase speed 20 fold
def InsertScan(isbn, shop_id):
    insert = "INSERT INTO scans ( isbn, shop_id ) VALUES ( ?, ? )"
    my_cursor.execute(insert, [isbn, shop_id])

tot_t = time.time() #Time entire run
shop_id = 1
barcode = 11111111111111
batch=[]
while shop_id < 5000:
    #barcode = raw_input("Scan ISBN: ")
    batch_cnt = 0
    while batch_cnt < 100:
        shop_id +=1
        barcode +=1
        batch_cnt +=1
        print "Recording scanned ISBN: ", barcode, shop_id
        batch.append((barcode,shop_id))
    print "Saving", str(len(batch)), "scanned ISBN's"
    t = time.time() #Time batch update
    for i in batch:
        InsertScan(i[0],i[1])
    batch=[]
    my_db.commit()
    t2 = time.time() - t
    print "Secs =", t2 #Print update time in seconds
print "Saving", str(len(batch)), "scanned ISBN's"
for i in batch: #Final update (just in case) or when program is quit
    InsertScan(i[0],i[1])
my_db.commit()
x = my_cursor.execute("select count(*) from scans")
tot_t2 = time.time() - tot_t
print "5000 Updates in ", tot_t2 #Print update time in seconds
for i in x:
    print i,"Total rows in scans table" #Print total of records in table
my_db.close()