async handleBulkInsert(data) {
        const values = [];
        const uniqueItems = new Set();

        for (let [item, price] of data) {
            item = Object.assign({}, item);

            // Store float as int32 to prevent float rounding errors
            // Postgres doesn't support unsigned types, so we use signed here
            const buf = Buffer.alloc(4);
            buf.writeFloatBE(item.floatvalue, 0);
            item.paintwear = buf.readInt32BE(0);

            if (item.floatvalue <= 0 && item.defindex !== 507) {
                // Only insert weapons, naive check
                // Special case for the 0 float Karambit
                continue;
            }

            // Postgres doesn't support unsigned 64 bit ints, so we convert them to signed
            item.s = utils.unsigned64ToSigned(item.s).toString();
            item.a = utils.unsigned64ToSigned(item.a).toString();
            item.d = utils.unsigned64ToSigned(item.d).toString();
            item.m = utils.unsigned64ToSigned(item.m).toString();

            const stickers = item.stickers.length > 0 ? item.stickers.map((s) => {
                const res = {s: s.slot, i: s.stickerId};
                if (s.wear) {
                    res.w = s.wear;
                }
                if (s.rotation) {
                    res.r = s.rotation;
                }
                if (s.offset_x) {
                    res.x = s.offset_x;
                }
                if (s.offset_y) {
                    res.y = s.offset_y;
                }
                return res;
            }) : null;

            if (stickers) {
                // Add a property on stickers with duplicates that signifies how many dupes there are
                // Only add this property to one of the dupe stickers in the array
                for (const sticker of stickers) {
                    const matching = stickers.filter((s) => s.i === sticker.i);
                    if (matching.length > 1 && !matching.find((s) => s.d > 1)) {
                        sticker.d = matching.length;
                    }
                }
            }

            const keychains = item.keychains.length > 0 ? item.keychains.map((s) => {
                const res = {s: s.slot, i: s.sticker_id};
                if (s.wear) {
                    res.w = s.wear;
                }
                if (s.scale) {
                    res.sc = s.scale;
                }
                if (s.rotation) {
                    res.r = s.rotation;
                }
                if (s.tint_id) {
                    res.t = s.tint_id;
                }
                if (s.offset_x) {
                    res.x = s.offset_x;
                }
                if (s.offset_y) {
                    res.y = s.offset_y;
                }
                if (s.offset_z) {
                    res.z = s.offset_z;
                }
                if (s.pattern) {
                    res.p = s.pattern;
                }
                return res;
            }) : null;

            const ms = item.s !== '0' ? item.s : item.m;
            const isStattrak = item.killeatervalue !== null;
            const isSouvenir = item.quality === 12;

            const props = Postgres.storeProperties(item.origin, item.quality, item.rarity);

            price = price || null;

            // Prevent two of the same item from being inserted in the same statement (causes postgres to get angry)
            const key = `${item.defindex}_${item.paintindex}_${item.paintwear}_${item.paintseed}`;
            if (uniqueItems.has(key)) {
                continue;
            } else {
                uniqueItems.add(key);
            }

            values.push([ms, item.a, item.d, item.paintseed, item.paintwear, item.defindex, item.paintindex, isStattrak,
                isSouvenir, props, JSON.stringify(stickers), JSON.stringify(keychains), item.rarity, price]);
        }

        if (values.length === 0) {
            return;
        }

        try {
            const query = Postgres.buildQuery(values.length);
            await this.pool.query(query, flatten(values));
            winston.debug(`Inserted/updated ${values.length} items`)
        } catch (e) {
            winston.warn(e);
        }
    }
Bulk handler to improve insert performance with 300+ rows at once
@param data [[item, price]]
@returns {Promise<void>}