pdf page to image c# itextsharp : Add attachment to pdf form Library control class asp.net web page azure ajax apis-php-en55-part1449

Caching queries
537
array(1) {
["id"]=>
string(1) "1"
}
NULL
PECL/mysqlnd_qc forbids caching of statements for which at least one column from the statements result
set shows no table name in its meta data by default. This is usually the case for columns originating from
SQL functions such as NOW() or LAST_INSERT_ID(). The policy aims to prevent pitfalls if caching by
default is used.
Example 8.4 Example showing which type of statements are not cached
mysqlnd_qc.enable_qc=1
mysqlnd_qc.cache_by_default=1
<?php
/* Connect, create and populate test table */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1)");
for ($i = 0; $i < 3; $i++) {
$start = microtime(true);
/* Note: statement will not be cached because of NOW() use */
$res = $mysqli->query("SELECT id, NOW() AS _time FROM test");
$row = $res->fetch_assoc();
/* dump results */
var_dump($row);
printf("Total time: %.6fs\n", microtime(true) - $start);
/* pause one second */
sleep(1);
}
?>
The above examples will output something similar to:
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
string(19) "2012-01-11 15:43:10"
}
Total time: 0.000540s
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
Add attachment to pdf form - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
allow saving of pdf form; change font pdf fillable form
Add attachment to pdf form - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
pdf save form data; allow users to save pdf form
Caching queries
538
string(19) "2012-01-11 15:43:11"
}
Total time: 0.000555s
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
string(19) "2012-01-11 15:43:12"
}
Total time: 0.000549s
It is possible to enable caching for all statements including those which has columns in their
result set for which MySQL reports no table, such as the statement from the example. Set
mysqlnd_qc.cache_no_table = 1 to enable caching of such statements. Please, note the difference
in the measured times for the above and below examples.
Example 8.5 Enabling caching for all statements using the mysqlnd_qc.cache_no_table ini
setting
mysqlnd_qc.enable_qc=1
mysqlnd_qc.cache_by_default=1
mysqlnd_qc.cache_no_table=1
<?php
/* Connect, create and populate test table */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1)");
for ($i = 0; $i < 3; $i++) {
$start = microtime(true);
/* Note: statement will not be cached because of NOW() use */
$res = $mysqli->query("SELECT id, NOW() AS _time FROM test");
$row = $res->fetch_assoc();
/* dump results */
var_dump($row);
printf("Total time: %.6fs\n", microtime(true) - $start);
/* pause one second */
sleep(1);
}
?>
The above examples will output something similar to:
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
C# PDF File Compress Library: Compress reduce PDF size in C#.net
File attachment. External cross references. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references: RasterEdge.Imaging.Basic.dll.
pdf editable fields; pdf form creator
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size Flatten form fields. File attachment.
changing font size in pdf form field; adding form fields to pdf
Setting the TTL
539
string(19) "2012-01-11 15:47:45"
}
Total time: 0.000546s
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
string(19) "2012-01-11 15:47:45"
}
Total time: 0.000187s
array(2) {
["id"]=>
string(1) "1"
["_time"]=>
string(19) "2012-01-11 15:47:45"
}
Total time: 0.000167s
Note
Although mysqlnd_qc.cache_no_table = 1 has been created for use with
mysqlnd_qc.cache_by_default = 1 it is bound it. The plugin will evaluate
the mysqlnd_qc.cache_no_table whenever a query is to be cached, no matter
whether caching has been enabled using a SQL hint or any other measure.
8.4.4 Setting the TTL
Copyright 1997-2014 the PHP Documentation Group.
The default invalidation strategy of the query cache plugin is Time to Live (TTL). The built-in storage
handlers will use the default TTL defined by the PHP configuration value mysqlnd_qc.ttl unless the
query string contains a hint for setting a different TTL. The TTL is specified in seconds. By default cache
entries expire after 30 seconds
The example sets mysqlnd_qc.ttl=3 to cache statements for three seconds by default. Every second
it updates a database table record to hold the current time and executes a SELECT statement to fetch the
record from the database. The SELECT statement is cached for three seconds because it is prefixed with
the SQL hint enabling caching. The output verifies that the query results are taken from the cache for the
duration of three seconds before they are refreshed.
Example 8.6 Setting the TTL with the mysqlnd_qc.ttl ini setting
mysqlnd_qc.enable_qc=1
mysqlnd_qc.ttl=3
<?php
/* Connect, create and populate test table */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id VARCHAR(255))");
for ($i = 0; $i < 7; $i++) {
/* update DB row  */
if (!$mysqli->query("DELETE FROM test") ||
C# Word: How to Compress, Decompress Word in C#.NET Projects
or sending the docx file through email attachment. Add those two RasterEdge assemblies to C# project & profession imaging controls, PDF document, image to pdf
convert word document to editable pdf form; pdf create fillable form
Setting the TTL
540
!$mysqli->query("INSERT INTO test(id) VALUES (NOW())"))
/* Of course, a real-life script should do better error handling */
die(sprintf("[%d] %s\n", $mysqli->errno, $mysqli->error));
/* select latest row but cache results */
$query  = "/*" . MYSQLND_QC_ENABLE_SWITCH . "*/";
$query .= "SELECT id AS _time FROM test";
if (!($res = $mysqli->query($query)) ||
!($row = $res->fetch_assoc()))
{
printf("[%d] %s\n", $mysqli->errno, $mysqli->error);
}
$res->free();
printf("Wall time %s - DB row time %s\n", date("H:i:s"), $row['_time']);
/* pause one second */
sleep(1);
}
?>
The above examples will output something similar to:
Wall time 14:55:59 - DB row time 2012-01-11 14:55:59
Wall time 14:56:00 - DB row time 2012-01-11 14:55:59
Wall time 14:56:01 - DB row time 2012-01-11 14:55:59
Wall time 14:56:02 - DB row time 2012-01-11 14:56:02
Wall time 14:56:03 - DB row time 2012-01-11 14:56:02
Wall time 14:56:04 - DB row time 2012-01-11 14:56:02
Wall time 14:56:05 - DB row time 2012-01-11 14:56:05
As can be seen from the example, any TTL based cache can serve stale data. Cache entries are not
automatically invalidated, if underlying data changes. Applications using the default TTL invalidation
strategy must be able to work correctly with stale data.
A user-defined cache storage handler can implement any invalidation strategy to work around this
limitation.
The default TTL can be overruled using the SQL hint /*qc_tt=seconds*/. The SQL hint must be
appear immediately after the SQL hint which enables caching. It is recommended to use the PHP constant
MYSQLND_QC_TTL_SWITCH instead of using the string value.
Example 8.7 Setting TTL with SQL hints
<?php
$start = microtime(true);
/* Connect, create and populate test table */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1), (2)");
printf("Default TTL\t: %d seconds\n", ini_get("mysqlnd_qc.ttl"));
/* Will be cached for 2 seconds */
$sql = sprintf("/*%s*//*%s%d*/SELECT id FROM test WHERE id = 1", MYSQLND_QC_ENABLE_SWITCH, MYSQLND_QC_TTL_SWITCH, 2);
$res = $mysqli->query($sql);
Pattern based caching
541
var_dump($res->fetch_assoc());
$res->free();
$mysqli->query("DELETE FROM test WHERE id = 1");
sleep(1);
/* Cache hit - no automatic invalidation and still valid! */
$res = $mysqli->query($sql);
var_dump($res->fetch_assoc());
$res->free();
sleep(2);
/* Cache miss - cache entry has expired */
$res = $mysqli->query($sql);
var_dump($res->fetch_assoc());
$res->free();
printf("Script runtime\t: %d seconds\n", microtime(true) - $start);
?>
The above examples will output something similar to:
Default TTL     : 30 seconds
array(1) {
["id"]=>
string(1) "1"
}
array(1) {
["id"]=>
string(1) "1"
}
NULL
Script runtime  : 3 seconds
8.4.5 Pattern based caching
Copyright 1997-2014 the PHP Documentation Group.
An application has three options for telling PECL/mysqlnd_qc whether a particular statement shall be used.
The most basic approach is to cache all statements by setting  mysqlnd_qc.cache_by_default = 1.
This approach is often of little practical value. But it enables users to make a quick estimation about the
maximum performance gains from caching. An application designed to use a cache may be able to prefix
selected statements with the appropriate SQL hints. However, altering an applications source code may
not always be possible or desired, for example, to avoid problems with software updates. Therefore, PECL/
mysqlnd_qc allows setting a callback which decides if a query is to be cached.
The callback is installed with the mysqlnd_qc_set_is_select function. The callback is given the
statement string of every statement inspected by the plugin. Then, the callback can decide whether to
cache the function. The callback is supposed to return FALSE if the statement shall not be cached. A return
value of TRUE makes the plugin try to add the statement into the cache. The cache entry will be given the
default TTL ( mysqlnd_qc.ttl). If the callback returns a numerical value it is used as the TTL instead of
the global default.
Example 8.8 Setting a callback with mysqlnd_qc_set_is_select
Pattern based caching
542
mysqlnd_qc.enable_qc=1
mysqlnd_qc.collect_statistics=1
<?php
/* callback which decides if query is cached */
function is_select($query) {
static $patterns = array(
/* true - use default from mysqlnd_qc.ttl */
"@SELECT\s+.*\s+FROM\s+test@ismU" => true,
/* 3 - use TTL = 3 seconds */
"@SELECT\s+.*\s+FROM\s+news@ismU" => 3
);
/* check if query does match pattern */
foreach ($patterns as $pattern => $ttl) {
if (preg_match($pattern, $query)) {
printf("is_select(%45s): cache\n", $query);
return $ttl;
}
}
printf("is_select(%45s): do not cache\n", $query);
return false;
}
/* install callback */
mysqlnd_qc_set_is_select("is_select");
/* Connect, create and populate test table */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1), (2), (3)");
/* cache put */
$mysqli->query("SELECT id FROM test WHERE id = 1");
/* cache hit */
$mysqli->query("SELECT id FROM test WHERE id = 1");
/* cache put */
$mysqli->query("SELECT * FROM test");
$stats = mysqlnd_qc_get_core_stats();
printf("Cache put: %d\n", $stats['cache_put']);
printf("Cache hit: %d\n", $stats['cache_hit']);
?>
The above examples will output something similar to:
is_select(                    DROP TABLE IF EXISTS test): do not cache
is_select(                    CREATE TABLE test(id INT)): do not cache
is_select(    INSERT INTO test(id) VALUES (1), (2), (3)): do not cache
is_select(             SELECT id FROM test WHERE id = 1): cache
is_select(             SELECT id FROM test WHERE id = 1): cache
is_select(                           SELECT * FROM test): cache
Cache put: 2
Cache hit: 1
The examples callback tests if a statement string matches a pattern. If this is the case, it either returns
TRUE to cache the statement using the global default TTL or an alternative TTL.
Slam defense
543
To minimize application changes the callback can put into and registered in an auto prepend file.
8.4.6 Slam defense
Copyright 1997-2014 the PHP Documentation Group.
A badly designed cache can do more harm than good. In the worst case a cache can increase database
server load instead of minimizing it. An overload situation can occur if a highly shared cache entry expires
(cache stampeding).
Cache entries are shared and reused to a different degree depending on the storage used. The default
storage handler stores cache entries in process memory. Thus, a cache entry can be reused for the life-
span of a process. Other PHP processes cannot access it. If Memcache is used, a cache entry can be
shared among multiple PHP processes and even among multiple machines, depending on the set up being
used.
If a highly shared cache entry stored, for example, in Memcache expires, many clients gets a cache miss.
Many client requests can no longer be served from the cache but try to run the underlying query on the
database server. Until the cache entry is refreshed, more and more clients contact the database server. In
the worst case, a total lost of service is the result.
The overload can be avoided using a storage handler which limits the reuse of cache entries to few
clients. Then, at the average, its likely that only a limited number of clients will try to refresh a cache entry
concurrently.
Additionally, the built-in slam defense mechanism can and should be used. If slam defense is activated
an expired cache entry is given an extended life time. The first client getting a cache miss for the expired
cache entry tries to refresh the cache entry within the extended life time. All other clients requesting
the cache entry are temporarily served from the cache although the original TTL of the cache entry has
expired. The other clients will not experience a cache miss before the extended life time is over.
Example 8.9 Enabling the slam defense mechanism
mysqlnd_qc.slam_defense=1
mysqlnd_qc.slam_defense_ttl=1
The slam defense mechanism is enabled with the PHP configuration directive
mysqlnd_qc.slam_defense. The extended life time of a cache entry is set with
mysqlnd_qc.slam_defense_ttl.
The function mysqlnd_qc_get_core_stats returns an array of statistics. The statistics
slam_stale_refresh and slam_stale_hit are incremented if slam defense takes place.
It is not possible to give a one-fits-all recommendation on the slam defense configuration. Users are
advised to monitor and test their setup and derive settings accordingly.
8.4.7 Finding cache candidates
Copyright 1997-2014 the PHP Documentation Group.
A statement should be considered for caching if it is executed often and has a long run time. Cache
candidates are found by creating a list of statements sorted by the product of the number of executions
Finding cache candidates
544
multiplied by the statements run time. The function mysqlnd_qc_get_query_trace_log returns a
query log which help with the task.
Collecting a query trace is a slow operation. Thus, it is disabled by default. The PHP configuration directive
mysqlnd_qc.collect_query_trace is used to enable it. The functions trace contains one entry for
every query issued before the function is called.
Example 8.10 Collecting a query trace
mysqlnd_qc.enable_qc=1
mysqlnd_qc.collect_query_trace=1
<?php
/* connect to MySQL */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
/* dummy queries to fill the query trace */
for ($i = 0; $i < 2; $i++) {
$res = $mysqli->query("SELECT 1 AS _one FROM DUAL");
$res->free();
}
/* dump trace */
var_dump(mysqlnd_qc_get_query_trace_log());
?>
The above examples will output:
array(2) {
[0]=>
array(8) {
["query"]=>
string(26) "SELECT 1 AS _one FROM DUAL"
["origin"]=>
string(102) "#0 qc.php(7): mysqli->query('SELECT 1 AS _on...')
#1 {main}"
["run_time"]=>
int(0)
["store_time"]=>
int(25)
["eligible_for_caching"]=>
bool(false)
["no_table"]=>
bool(false)
["was_added"]=>
bool(false)
["was_already_in_cache"]=>
bool(false)
}
[1]=>
array(8) {
["query"]=>
string(26) "SELECT 1 AS _one FROM DUAL"
["origin"]=>
string(102) "#0 qc.php(7): mysqli->query('SELECT 1 AS _on...')
#1 {main}"
Finding cache candidates
545
["run_time"]=>
int(0)
["store_time"]=>
int(8)
["eligible_for_caching"]=>
bool(false)
["no_table"]=>
bool(false)
["was_added"]=>
bool(false)
["was_already_in_cache"]=>
bool(false)
}
}
Assorted information is given in the trace. Among them timings and the origin of the query call. The origin
property holds a code backtrace to identify the source of the query. The depth of the backtrace can be
limited with the PHP configuration directive mysqlnd_qc.query_trace_bt_depth. The default depth is
3.
Example 8.11 Setting the backtrace depth with the mysqlnd_qc.query_trace_bt_depth ini
setting
mysqlnd_qc.enable_qc=1
mysqlnd_qc.collect_query_trace=1
<?php
/* connect to MySQL */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1), (2), (3)");
/* dummy queries to fill the query trace */
for ($i = 0; $i < 3; $i++) {
$res = $mysqli->query("SELECT id FROM test WHERE id = " . $mysqli->real_escape_string($i));
$res->free();
}
$trace = mysqlnd_qc_get_query_trace_log();
$summary = array();
foreach ($trace as $entry) {
if (!isset($summary[$entry['query']])) {
$summary[$entry['query']] = array(
"executions" => 1,
"time"       => $entry['run_time'] + $entry['store_time'],
);
} else {
$summary[$entry['query']]['executions']++;
$summary[$entry['query']]['time'] += $entry['run_time'] + $entry['store_time'];
}
}
foreach ($summary as $query => $details) {
printf("%45s: %5dms (%dx)\n",
$query, $details['time'], $details['executions']);
}
?>
Measuring cache efficiency
546
The above examples will output something similar to:
DROP TABLE IF EXISTS test:     0ms (1x)
CREATE TABLE test(id INT):     0ms (1x)
INSERT INTO test(id) VALUES (1), (2), (3):     0ms (1x)
SELECT id FROM test WHERE id = 0:    25ms (1x)
SELECT id FROM test WHERE id = 1:    10ms (1x)
SELECT id FROM test WHERE id = 2:     9ms (1x)
8.4.8 Measuring cache efficiency
Copyright 1997-2014 the PHP Documentation Group.
PECL/mysqlnd_qc offers three ways to measure the cache efficiency. The function
mysqlnd_qc_get_normalized_query_trace_log returns statistics aggregated by the normalized
query string, mysqlnd_qc_get_cache_info gives storage handler specific information which includes
a list of all cached items, depending on the storage handler. Additionally, the core of PECL/mysqlnd_qc
collects high-level summary statistics aggregated per PHP process. The high-level statistics are returned
by mysqlnd_qc_get_core_stats.
The functions mysqlnd_qc_get_normalized_query_trace_log and
mysqlnd_qc_get_core_stats will not collect data unless data collection has been enabled through
their corresponding PHP configuration directives. Data collection is disabled by default for performance
considerations. It is configurable with the mysqlnd_qc.time_statistics option, which determines if timing
information should be collected. Collection of time statistics is enabled by default but only performed if data
collection as such has been enabled. Recording time statistics causes extra system calls. In most cases,
the benefit of the monitoring outweighs any potential performance penalty of the additional system calls.
Example 8.12 Collecting statistics data with the mysqlnd_qc.time_statistics ini setting
mysqlnd_qc.enable_qc=1
mysqlnd_qc.collect_statistics=1
<?php
/* connect to MySQL */
$mysqli = new mysqli("host", "user", "password", "schema", "port", "socket");
$mysqli->query("DROP TABLE IF EXISTS test");
$mysqli->query("CREATE TABLE test(id INT)");
$mysqli->query("INSERT INTO test(id) VALUES (1), (2), (3)");
/* dummy queries */
for ($i = 1; $i <= 4; $i++) {
$query = sprintf("/*%s*/SELECT id FROM test WHERE id = %d", MYSQLND_QC_ENABLE_SWITCH, $i % 2);
$res   = $mysqli->query($query);
$res->free();
}
var_dump(mysqlnd_qc_get_core_stats());
?>
Documents you may be interested
Documents you may be interested