diff --git a/src/database/rawExecute.ts b/src/database/rawExecute.ts
index 4715126..42895b9 100644
--- a/src/database/rawExecute.ts
+++ b/src/database/rawExecute.ts
@@ -1,11 +1,11 @@
 import { pool } from '.';
 import { printError, profileBatchStatements, runProfiler } from '../logger';
-import { CFXCallback, CFXParameters } from '../types';
+import { CFXCallback, CFXParameters, QueryType } from '../types';
 import { parseResponse } from '../utils/parseResponse';
 import { executeType, parseExecute } from '../utils/parseExecute';
 import { scheduleTick } from '../utils/scheduleTick';
 import { isServerConnected, waitForConnection } from '../database';
-import { setCallback } from '../utils/setCallback'
+import { setCallback } from '../utils/setCallback';
 
 export const rawExecute = async (
   invokingResource: string,
@@ -15,20 +15,18 @@ export const rawExecute = async (
   isPromise?: boolean,
   unpack?: boolean
 ) => {
-  if (typeof query !== 'string')
-    return printError(
-      invokingResource,
-      cb,
-      isPromise,
-      query,
-      `Expected query to be a string but received ${typeof query} instead.`
-    );
+  cb = setCallback(parameters, cb);
 
-  const type = executeType(query);
-  const placeholders = query.split('?').length - 1;
+  let type: QueryType;
+  let placeholders: number;
 
-  cb = setCallback(parameters, cb);
-  parameters = parseExecute(placeholders, parameters);
+  try {
+    type = executeType(query);
+    placeholders = query.split('?').length - 1;
+    parameters = parseExecute(placeholders, parameters);
+  } catch (err: any) {
+    return printError(invokingResource, cb, isPromise, query, err.message);
+  }
 
   if (!isServerConnected) await waitForConnection();
 
@@ -63,32 +61,30 @@ export const rawExecute = async (
       if (hasProfiler && ((index > 0 && index % 100 === 0) || index === parametersLength - 1)) {
         await profileBatchStatements(connection, invokingResource, query, parameters, index < 100 ? 0 : index);
       }
+    }
 
-      if (index === parametersLength - 1) {
-        if (!cb) return;
+    if (!cb) return;
 
-        try {
-          if (response.length === 1) {
-            if (unpack && type === null) {
-              if (response[0][0] && Object.keys(response[0][0]).length === 1) {
-                cb(Object.values(response[0][0])[0]);
-              } else cb(response[0][0]);
-            } else {
-              cb(response[0]);
-            }
-          } else {
-            cb(response);
-          }
-        } catch (err) {
-          if (typeof err === 'string') {
-            if (err.includes('SCRIPT ERROR:')) return console.log(err);
-            console.log(`^1SCRIPT ERROR in invoking resource ${invokingResource}: ${err}^0`);
-          }
+    try {
+      if (response.length === 1) {
+        if (unpack && type === null) {
+          if (response[0][0] && Object.keys(response[0][0]).length === 1) {
+            cb(Object.values(response[0][0])[0]);
+          } else cb(response[0][0]);
+        } else {
+          cb(response[0]);
         }
+      } else {
+        cb(response);
+      }
+    } catch (err) {
+      if (typeof err === 'string') {
+        if (err.includes('SCRIPT ERROR:')) return console.log(err);
+        console.log(`^1SCRIPT ERROR in invoking resource ${invokingResource}: ${err}^0`);
       }
     }
   } catch (err: any) {
-    printError(invokingResource, cb, isPromise, query, err.message);
+    printError(invokingResource, cb, isPromise, `Query: ${query}`, err.message);
 
     TriggerEvent('oxmysql:error', {
       query: query,
diff --git a/src/database/rawQuery.ts b/src/database/rawQuery.ts
index 5c603c8..fb73368 100644
--- a/src/database/rawQuery.ts
+++ b/src/database/rawQuery.ts
@@ -16,17 +16,12 @@ export const rawQuery = async (
   cb?: CFXCallback,
   isPromise?: boolean
 ) => {
-  if (typeof query !== 'string')
-    return printError(
-      invokingResource,
-      cb,
-      isPromise,
-      query,
-      `Expected query to be a string but received ${typeof query} instead.`
-    );
-
   cb = setCallback(parameters, cb);
-  [query, parameters] = parseArguments(invokingResource, query, parameters);
+  try {
+    [query, parameters] = parseArguments(query, parameters);
+  } catch (err: any) {
+    return printError(invokingResource, cb, isPromise, `Query: ${query}`, err.message);
+  }
 
   if (!isServerConnected) await waitForConnection();
 
@@ -56,7 +51,7 @@ export const rawQuery = async (
         }
       }
   } catch (err: any) {
-    printError(invokingResource, cb, isPromise, query, JSON.stringify(parameters), err.message);
+    printError(invokingResource, cb, isPromise, `Query: ${query}`, JSON.stringify(parameters), err.message);
 
     TriggerEvent('oxmysql:error', {
       query: query,
diff --git a/src/database/rawTransaction.ts b/src/database/rawTransaction.ts
index 7dcbf13..e5499a9 100644
--- a/src/database/rawTransaction.ts
+++ b/src/database/rawTransaction.ts
@@ -18,17 +18,24 @@ export const rawTransaction = async (
   cb?: CFXCallback,
   isPromise?: boolean
 ) => {
+  let transactions;
+  cb = setCallback(parameters, cb);
+
+  try {
+    transactions = parseTransaction(queries, parameters);
+  } catch (err: any) {
+    return printError(invokingResource, cb, isPromise, err.message);
+  }
+
   if (!isServerConnected) await waitForConnection();
 
   scheduleTick();
 
-  cb = setCallback(parameters, cb);
-  const transactions = parseTransaction(invokingResource, queries, parameters);
   const connection = await pool.getConnection();
-  const hasProfiler = await runProfiler(connection, invokingResource);
   let response = false;
 
   try {
+    const hasProfiler = await runProfiler(connection, invokingResource);
     await connection.beginTransaction();
     const transactionsLength = transactions.length;
 
diff --git a/src/logger/index.ts b/src/logger/index.ts
index 68ea689..e831073 100644
--- a/src/logger/index.ts
+++ b/src/logger/index.ts
@@ -9,7 +9,7 @@ export function printError(
   isPromise: boolean | undefined,
   ...args: string[]
 ) {
-  const err = `${invokingResource} was unable to execute a query!\nQuery: ${args.join('\n')}`;
+  const err = `${invokingResource} was unable to execute a query!\n${args.join('\n')}`;
 
   if (cb && isPromise) return cb(null, err);
 
diff --git a/src/utils/parseArguments.ts b/src/utils/parseArguments.ts
index f12787d..d92f6a1 100644
--- a/src/utils/parseArguments.ts
+++ b/src/utils/parseArguments.ts
@@ -1,11 +1,9 @@
 import type { CFXParameters } from '../types';
 import { convertNamedPlaceholders } from '../config';
 
-export const parseArguments = (
-  invokingResource: string,
-  query: string,
-  parameters?: CFXParameters
-): [string, CFXParameters] => {
+export const parseArguments = (query: string, parameters?: CFXParameters): [string, CFXParameters] => {
+  if (typeof query !== 'string') throw new Error(`Expected query to be a string but received ${typeof query} instead.`);
+
   if (convertNamedPlaceholders && parameters && typeof parameters === 'object' && !Array.isArray(parameters))
     if (query.includes(':') || query.includes('@')) {
       const placeholders = convertNamedPlaceholders(query, parameters);
@@ -32,11 +30,7 @@ export const parseArguments = (
       if (diff > 0) {
         for (let i = 0; i < diff; i++) parameters[queryParams.length + i] = null;
       } else if (diff < 0) {
-        throw new Error(
-          `${invokingResource} was unable to execute a query!\nExpected ${
-            queryParams.length
-          } parameters, but received ${parameters.length}.\n${`${query} ${JSON.stringify(parameters)}`}`
-        );
+        throw new Error(`Expected ${queryParams.length} parameters, but received ${parameters.length}.`);
       }
     }
   }
diff --git a/src/utils/parseExecute.ts b/src/utils/parseExecute.ts
index de03fbd..54f52aa 100644
--- a/src/utils/parseExecute.ts
+++ b/src/utils/parseExecute.ts
@@ -1,6 +1,8 @@
 import { CFXParameters } from '../types';
 
 export const executeType = (query: string) => {
+  if (typeof query !== 'string') throw new Error(`Expected query to be a string but received ${typeof query} instead.`);
+
   switch (query.substring(0, query.indexOf(' '))) {
     case 'INSERT':
       return 'insert';
diff --git a/src/utils/parseTransaction.ts b/src/utils/parseTransaction.ts
index 03bd614..bbb7871 100644
--- a/src/utils/parseTransaction.ts
+++ b/src/utils/parseTransaction.ts
@@ -4,7 +4,7 @@ import { parseArguments } from './parseArguments';
 const isTransactionQuery = (query: TransactionQuery | string): query is TransactionQuery =>
   (query as TransactionQuery).query !== undefined;
 
-export const parseTransaction = (invokingResource: string, queries: TransactionQuery, parameters: CFXParameters) => {
+export const parseTransaction = (queries: TransactionQuery, parameters: CFXParameters) => {
   if (!Array.isArray(queries)) throw new Error(`Transaction queries must be array, received '${typeof queries}'.`);
 
   if (!parameters || typeof parameters === 'function') parameters = [];
@@ -13,7 +13,7 @@ export const parseTransaction = (invokingResource: string, queries: TransactionQ
     const transactions = queries.map((query) => {
       if (typeof query[1] !== 'object')
         throw new Error(`Transaction parameters must be array or object, received '${typeof query[1]}'.`);
-      const [parsedQuery, parsedParameters] = parseArguments(invokingResource, query[0], query[1]);
+      const [parsedQuery, parsedParameters] = parseArguments(query[0], query[1]);
 
       return { query: parsedQuery, params: parsedParameters };
     });
@@ -27,7 +27,6 @@ export const parseTransaction = (invokingResource: string, queries: TransactionQ
     }
 
     const [parsedQuery, parsedParameters] = parseArguments(
-      invokingResource,
       isTransactionQuery(query) ? query.query : query,
       isTransactionQuery(query) ? query.parameters || query.values : parameters
     );