View source for 'Preparing' SQL Statements And Specifying SQL Statement Time-outs

==Overview==
This page deals with the advanced DB access topics of Prepared Statements and custom SQL Statement time-outs. Please note that both are used and needed only in special circumstances.

===Prepared Statements===
'Preparing' a SQL query lets the software engineer ''optimise the performance of ''frequently issued'' queries''. 

What a RDBMS does when it encounters a 'Prepared' SQL query is that it 'caches' the 'query execution plan' and uses this cached information in subsequent calls. Since the calculation of a query execution plan takes time, and since spending that time is no longer needed in subsequent runs of the same query, it ''makes subsequent runs of the ''same'' SQL query faster''. While the caching of the 'query execution plan' takes a bit of time when the SQL statement gets 'prepared', this is one-off and pays off with subsequent calls to the same query.

A SQL query that uses Parameters and gets 'prepared' is treated as 'prepared' even with varying values for the Parameters and hence fully benefits from the speed-up that a Prepared Statement can yield!<br />
The 'prepare' step itself is always performed before an SQL query is executed. As you don't want that step to be repeated each time if you are executing SQL statements in a loop you'll need to 'prepare' the statement before you enter the loop.<br/>As long as the cursor is not marked as 'finished or closed', the cached execution plan continues to be valid.<br />If 'finished/closed' SQL queries are called again, they are treated as 'unprepared' SQL queries and therefore are significantly slower, as each time the 'prepare' step must be performed again.<br />Therefore all SQL queries that are called within a loop or with changing parameters should always be 'prepared' statements with their 'finish' clause after the point where the loop has ended.<br /><br />
query->prepare()<br />
start loop
: query->execute()
end loop<br />
query->finish()

Prepared Statements are not supported by all RDBMS, but should simply be executed in a non-prepared way in case a RDBMS doesn't support it. PostgreSQL definitely supports Prepared Statements.

====Utilising 'Prepared' Statements====
To use Prepared Statements, call one of the Methods of an instance of the <code>TDataBase</code> Class (e.g. <code>DBAccess.GDBAccessObj</code>) that has got an <code>APrepareCommand</code> or <code>APrepareSelectCommand</code> Argument. (Those Arguments always default to false.)

[[Demo Project for Raw Timings of 'Prepared' Statements]]

===Customising SQL Statement Time-outs===
Every <code>DbCommand</code> that is run against the DB has got a time-out associated with it. If the command execution takes longer than the time-out, the ADO.NET provider for the RDBMS that we are connected to will throw an Exception. 

In case of the PostgreSQL RDBMS we use the Npgsql ADO.NET provider, and this throws an Exception when a command takes longer than the default, which is 20 seconds: <code>Npgsql.NpgsqlException: ERROR: 57014: canceling statement due to statement timeout</code>

When a single SQL query takes longer than 20 seconds on a machine where both the PetraServerConsole.exe and the RDBMS are located on the same machine (which is the normal deployment scenario), 
* it points to either a rather inefficient SQL query (perhaps it needs to use one or more Indexes for better performance), or 
* the SQL query is simply attempting to do 'too much in one go'.<br /> There are of course plenty of ways to optimize queries - next to splitting the query into smaller parts - and make the DB’s optimizer choose the right method <br />such as using indexes, optimizer hints or simply put the joined tables in the right order.

If you can't optimise the speed of the SQL query and can't break down what the SQL query does and you are running into Exceptions because of Command time-outs then the time-out should be manually increased for that one query. See below on how to do that.

====Utilising Customised SQL Statement Time-outs====
To customise SQL statement time-outs, call one of the Methods of an instance of the <code>TDataBase</code> Class (e.g. <code>DBAccess.GDBAccessObj</code>) that has got an <code>ACommandTimeout</code> or <code>ASelectCommandTimeout</code> Argument. (Those Arguments always default to -1, which means the default timeout of 20 seconds will be used.)

Pass in an <code>int</code> value higher than 20 into one of those Arguments to increase the SQL statement time-out.


==Notes==
It should be noted that there is no inter-relation between 'prepared' statements and custom SQL Statement time-outs.


==Questions?==
In case you have questions regarding the features that get explained on this page please contact ChristianK, the developer of those features.