I didn't use whatever duplicate questions but wondering if somebody can offer good quality good examples and specifically guidelines around these.

Prepared Claims are precompiled claims that you could run multiple occasions against around the database, and SQLServer will not parse or produce a different execution plan every time you run it. Usually, you take prepared statement inside a client context (using JDBC, ADO.Internet, ODBC or other client access technology).

A prepared statement in Java (using JDBC, obviously) is going to be something similar to:

PreparedStatement ps = conn.prepareStatmente("insert into t(field1) values (?)");
ps.setString(1, "Hello");
ps.executeUpdate();
ps.setStrgin(2, "World");
ps.executeUpdate();
ps.close();
// two rows will be inserted into table t:
// field1 => "Hello"
// field1 => "world"

Dynamic SQL is a chance to run any SQL sentence saved inside a dynamic variable (i.e. a string) in the saved procedure or function in SQLServer. You'll find some good examples within the link provided.

It would be simpler to describe with a few context...

In Java, PreparedStatements are SQL claims inside a Java String and supports placeholders you are able to populate without having to worry about getting away single quotes. .NET also has PreparedStatement syntax:

Prepared execution is generally utilized by programs to complete exactly the same parameterized SQL statement frequently. Prepared execution is faster than direct execution for claims performed a lot more than 3 or 4 occasions since the statement is put together only one time, while claims performed directly are put together every time they're performed. Prepared execution can provide a decrease in network traffic since the driver can send an execution plan identifier and also the parameter values, instead of a whole SQL statement, towards the databases every time the statement is performed.

One step lacking utilizing a Saved Procedure...

MySQL's dynamic SQL syntax is also called PreparedStatements...

Dynamic SQL

Dynamic SQL is essentially any SQL declared like a string data type - it may be personalized before execution. The requirement for using dynamic SQL comes when for you to do such things as dynamic column and/or table references. For instance, no SQL supports a string variable to represent the table within the FROM clause (Table Valued Variables are the best, where supported).

You need to be aware of distinction between EXEC and EXEC sp_executesql regarding dynamic SQL on SQL Server. EXEC sp_executesql was put in SQL Server 2005, and you will find out more about dynamic SQL on SQL Server within the excellent article: The Curse and Blessings of Dynamic SQL

PreparedStaement is really a language construct that delivers pre-put together queries that was already described in above solutions. One extremely important advantage of using prepared claims is they help you save from malicious SQL injection attacks. How? you simply have placeholder that you can place in values with no other to change the query (pre-put together), whereas just in case of Claims, you are able to affect the query string. Example:

I've got a query to update a table -

UPDATE table_name SET col1 = 40 WHERE id = 'A001';

This is often changed (maliciously) as -

UPDATE table_name SET col1 = 40 WHERE id = 'A001'; DROP TABLE table_name;

As well as your table is finished!

Dynamic queries really are a database construct that allows you to write a question in that can be used bind variables rather using values. They are particularly utilized in PL/SQL code. Also helpful in performing DDL claims. Example code (Oracle):

ip_job_name := 'APP_EXTRACT'; lv_query := 'SELECT 1 FROM user_table WHERE table_name = :tab_name';

BEGIN

EXECUTE IMMEDIATE lv_query INTO lv_tab USING ip_job_name;

EXECUTE IMMEDIATE 'DROP TABLE ' || ip_job_name;

EXCEPTION

WHEN NO_DATA_FOUND THEN NULL;

END;