SQL> source /u01/app/oracle/product/12.1/bin/oracle_env.sh
SQL> sqlplus system/system_password
SQL> alter user hr identified by <password-for-hr> account unlock;

The AnyCo sample application will use Database Resident Connection Pooling (DRCP) to show how a PHP application can scale to support many users.

PHP cannot be assumed to be thread safe and is typically run in a multi-process mode, for example with the Apache web server's pre-fork model or with FastCGI. Sharing Oracle connections between active and idle PHP processes is not possible in the mid-tier because there is no interprocess communication. DRCP works because the sharing is handled by the database host machine. This also allows connection resources created by multiple mid-tier hosts to be shared.

For best performance it is common for PHP OCI8 applications to use "persistent" database connections. When PHP has completed an application script and sent its output to the web user's browser, the script's underlying DB connection is not closed. The connection remains cached in the still-running, now idle PHP/Apache process. It can be reused by this PHP process in any subsequent PHP script connecting with the same database credentials. This has great performance benefits. However without DRCP, when there are large numbers of PHP processes the open database connections may use a large amount of database host memory. This is despite many connections being idle due to the user's "think-time" between making web page requests, or while the PHP script runs non-database operations.

DRCP allows PHP applications to efficiently use database host memory to support large numbers of web users. DRCP allows database resources to be used by only those web users currently doing database operations. Benchmarks have shown DRCP can support tens of thousands of web users on small, commodity Linux database hosts.

DRCP overcomes the database host memory pressure by maintaining a small pool of database server processes on the host. These can be shared by all the PHP database connections across all PHP processes and mid-tier servers when they are needed.

If a PHP script connects to the database but there is no pooled server process available, then it will wait until one is free. This prevents the database from being overloaded and allows applications to continue running.

Once the DRCP pool is started, applications can choose at runtime whether to use it or not. This is indicated in the PHP OCI8 connection string. Typically only short lived, similar kinds of tasks should use DRCP. Batch processes should not use the pool.

The DRCP pool can be used in two variants. The basic method is that only the processes are reused. The second method increases performance by also reusing the "session" memory associated with each process. In PHP, only "persistent" connections use the latter method. For web applications like PHP where each script is part of a single application, this session memory sharing is generally perfectly acceptable. However care must be taken that any retained session settings such as the date format do not occur unexpectedly and that they do not constitute an information security leak. DRCP allows the pool to be virtually sub-partitioned to reduce any issues like this.

PHP OCI8 applications use the oci_pconnect() call to create a persistent database connection. Applications can also connect to Oracle using oci_connect() or oci_new_connect(), which create non-persistent connections. The oci_new_connect() function always returns a new, transactionally independent connection resource each time it is called. The oci_connect() and oci_pconnect() functions will return their respective same PHP resource if a running script calls them multiple times with the same connection credentials. For each connection method, a rollback occurs at the end of each script, if necessary.

There are also differences in behavior between the three functions depending on whether DRCP is being used.

Without DRCP, a persistent connection remains open even when the PHP script has completed. A subsequent script connecting with the same credentials can immediately reuse that connection. This is fast but the database host must have enough memory to maintain the connections from each PHP process even when the processes are idle. The oci_connect() and oci_new_connect() functions do not retain the underlying connection to the database after the PHP script completes. This makes connection slower to establish but memory use on the database host is capped by the number of active web users.

When PHP connections uses DRCP, all three OCI8 connection functions benefit from using established DRCP server processes from the DRCP pool. When each script finishes (if not earlier), its database pooled server is returned to the DRCP pool for reuse. A lightweight connection to the DRCP broker is retained, which aids re-connection performance. An oci_pconnect() function will reuse the process session memory, provide more efficiency and higher scalability. Each oci_connect() and oci_new_connect() call will recreate the Oracle session memory in the reused DRCP pooled process.

More information on DRCP and PHP is in the white paper:

http://www.oracle.com/technetwork/topics/php/whatsnew/php-scalability-ha-twp-128842.pdf

1. Enter the following URL in your Web browser:

   http://httpd.apache.org/download.cgi
   

2. Click the httpd-2.2.17-win32-x86-no_ssl.msi.
3. Save the downloaded file in a temporary directory, such as c:\tmp and double click to install it.

   The software will install to a directory like: C:\Program Files\Apache Software Foundation\Apache2.2.

   The file name and extraction directory are based on the current version. Throughout this procedure, ensure you use the directory name for the version you are installing.

4. Download the Apache mod_fcgid FastCGI component from the following URL:

   http://httpd.apache.org/download.cgi#mod_fcgid

5. Unzip it to the installed Apache 2.2 directory.
6. Edit C:\Program Files\Apache Software Foundation\Apache2.2\conf\httpd.conf and add:

   LoadModule fcgid_module modules/mod_fcgid.so
   

   In httpd.conf locate the <Directory> section for htdocs and add ExecCGI to the Options:

   <Directory "C:/Program Files/Apache Software Foundation/Apache2.2/htdocs">
   ...
   Options Indexes FollowSymLinks ExecCGI
   ...
   </Directory>
   

# /usr/local/apache/bin/apachectl start

# /usr/local/apache/bin/apachectl stop

export ORACLE_HOME=/u01/app/oracle/product/12.1
export LD_LIBRARY_PATH=$ORACLE_HOME/lib:$LD_LIBRARY_PATH

1. Download the PHP 5.3.6 zip file from the following Web site:

   http://windows.php.net/download/

   Use the non-thread safe bundle because we will install it in FastCGI mode.

2. In Windows Explorer, go to the directory where you downloaded the PHP 5.3.6 zip file.
3. Unzip the PHP package to a directory called C:\php-5.3.6
4. Copy php.ini-development to C:\php-5.3.6\php.ini
5. Edit php.ini to make the following changes:

   • Add the line extension_dir = "C:\php-5.3.6\ext".

     This is the directory containing the PHP extensions.

   • Remove the semicolon from the beginning of the line

     extension=php_oci8_11g.dll

6. Edit C:\Program Files\Apache Software Foundation\Apache2.2\conf\httpd.conf and add the following lines. Make sure you use forward slashes '/' and not back slashes '\':

   FcgidInitialEnv PHPRC "c:/php-5.3.6"
   AddHandler fcgid-script .php
   FcgidWrapper "c:/php-5.3.6/php-cgi.exe" .php
   

   Make sure mod_fcgid.so is loaded and the ExecCGI option set as described previously in the section “Installing Apache on Windows XP”.

7. Restart the Apache Server so that you can test your PHP installation.

   If you have errors, double check your httpd.conf and php.ini files. Make sure you rebooted the machine after installing Oracle Database so that the PATH environment variable includes the Oracle libraries.

# yum install php53 php53-gd

# up2date php53 php53-gd

# yum install php53-oci8-11gR2

# up2date php53-oci8-11gR2

extension=oci8.so

1. Setting the timezone is a new requirement of PHP 5.3.

   date.timezone = America/Los_Angeles
   

2. For testing it is helpful to set PHP's display_errors to show messages in the output text, instead of hiding them in Apache log files. In php.ini locate the display_errors setting and change it to On if necessary. If the directive does not exist, add the line:

   display_errors = On
   

3. The DRCP connection class should be configured in php.ini. The name is a user-chosen string to distinguish this application from any others that also use DRCP. If the class is not set, Oracle will not be able to share the DRCP pool effectively.

   Add a class name entry, such as:

   oci8.connection_class = ACXE
   

   Save the configuration file.

   If you are on Linux, make sure you have also done the steps in the earlier section “Setting the Oracle Environment for Apache on Linux”.

4. Restart Apache.

1. Download NetBeans 7.0 with the Java SE Development Kit from the following location:

   http://www.oracle.com/technetwork/java/javase/downloads/jdk-netbeans-jsp-142931.html

2. In Windows Explorer, locate the downloaded file jdk-6u25-nb-7_0-windows-ml.exe and run it by double clicking it.
3. After installation, start NetBeans by navigating to Start, then All Programs, then NetBeans, and then NetBeans IDE 7.0.
4. From Run Tools, select Plugins.
5. Go to the Available Plugins tab and select all the options in the PHP category.
6. Click Install and agree to the license and location.
7. Restart the IDE when prompted.

1. Download the NetBeans 7.0 PHP bundle from the following Web site:

   http://netbeans.org/downloads/

2. On Linux open a terminal window and run the installer:

   # sh netbeans-7.0-ml-php-linux.sh
   

3. If your JDK is not installed in a default location, specify the path when installing, for example:

   # sh netbeans-6.9-ml-php-linux.sh --javahome $HOME/jdk1.6.0_24
   

4. Accept the license
5. Confirm the install directory.
6. Confirm the location of your JDK.

1. Start NetBeans by using the desktop icon or menu entry. Navigate to Tools and then Options.
2. In the General options choose your preferred browser.
3. In the PHP options, go to the General tab.
4. Set the PHP 5 interpreter to your PHP command line executable, for example /usr/bin/php, /usr/local/bin/php, or C:\php-5.3.6\php.exe.

1. Navigating to File, then New Project, or clicking the New Project Icon, or using Ctrl + Shift + N.
2. Choose PHP and PHP Application.
3. Change the Project name to ACXE.
4. Choose your folder where the source files will be kept. For ease of install, use a directory that Apache can access such as /home/chris/public_html/ACXE.
5. Set the PHP Version to PHP 5.3
6. Set the project URL to map the directory where the sources are located. For example, http://localhost:8888/~chris/ACXE/, if you use a non default Apache port. Do not use a framework.
7. The project will be created and an index.php file will be set to the default NetBeans template.
   
8. Put some content in index.php to verify it can be run. Inside the <?php ?> tags, replace the comment line // put your code here with

   echo "hi";
   

9. Run the file by selecting Run Project from Run, or press F6. A browser window will open with the newly added message:
   
10. If the URL is not correct and does not map to the file on disk, right click on the project name in the Project navigator and select Properties. Select Run Configuration and change the Project URL.