Step 1: Building the Berkeley DB
Here is the document to get you started.

Step 2: Rename Binaries
Once you have built the binaries (libdb_sql50.dll and dbsql.exe) rename those files to sqlite3.dll and sqlite3.exe.

Step 3: Copy File to the Mobile Server
Copy those files to the Mobile Server under the following path:
$ORACLE_HOME/mobile/server/admin/repository/setup/common/win32/sqlite/

Modify the following file:
$ORACLE_HOME/mobile/server/admin/repository/setup/dmc/common/sqlite_win32.inf

Add the following entry that is in bold lettering:

<item>
<src>/common/win32/sqlite/sqlite3.dll</src>
<des>$APP_DIR$\bin\sqlite3.dll</des>
</item>
<item>
<src>/common/win32/sqlite/sqlite3.exe</src>
<des>$APP_DIR$\bin\sqlite3.exe</des>
</item>


This is optional.  The sqlite3.exe is equivalent to msql or sql*plus.

You should now be able to run the setup.exe for the SQLite Win32 and the client will be set up for Berkeley DB SQL API.

If you perform a sync with the SQLite client, your directory structure will look something like this:

08/26/2010 01:25 PM 41,984 default.db
08/26/2010 08:42 PM 67,584 fod.db
08/26/2010 08:42 PM 20,480 OSE$default.db
08/26/2010 08:42 PM 34,816 OSE$fod.db


By using the Berkeley DB SQL API, your structure will differ by having <database>-journal folders.

08/26/2010 09:44 PM 32,768 default.db
08/26/2010 09:44 PM <DIR> default.db-journal
08/26/2010 09:44 PM 32,768 fod.db
08/26/2010 09:44 PM <DIR> fod.db-journal
08/26/2010 09:44 PM 32,768 OSE$default.db
08/26/2010 09:44 PM <DIR> OSE$default.db-journal
08/26/2010 09:44 PM 32,768 OSE$fod.db
08/26/2010 09:44 PM <DIR> OSE$fod.db-journal

For a lot of the Oracle SQL Developers, some things you will need to brush up on while using the new SQLite environment. Lack of Stored Procedures… but since Berkeley DB source code is availble as open source, a developer should be able to add functions to be able to perform the same tasks. SQLite doesn’t support sequences in the same way Oracle supports sequences. So, to have the ability to sync your sequences to the client, you will need to performance the following sql statements to keep your client and server in sync for sequences.

To get the nextval of a sequence
SELECT IFNULL((CUR_VALUE + INCREMENT_BY ), MIN_VALUE )
FROM C$SEQ_CLIENTS
WHERE NAME = 'MY_SEQ';

To update the sequence with the current value
UPDATE C$SEQ_CLIENTS
SET CUR_VALUE = IFNULL((CUR_VALUE + INCREMENT_BY ), MIN_VALUE )
WHERE NAME = 'MY_SEQ';

Other differences are obvious ones like SQL functions. As I do a little bit more development with Berkeley DB, I will try to benchmark it against the SQLite flavour and the Oracle Lite database to see how everything stacks up.

Session ID: S317033
Title: Oracle Berkeley DB: Enabling Your Mobile Data Strategy
Abstract: Mobile data is everywhere. Deploying applications and updates, as well as collecting data from the field and synchronizing it with the Oracle Database server infrastructure, is everyone’s concern today in IT. Mobile devices, by their very nature, are easily damaged, lost, or stolen. Therefore, enabling secure, rapid mobile deployment and synchronization is critically important. By combining Oracle Berkeley DB 11g and Oracle Database Lite Mobile Server, you can easily link your mobile devices, users, applications, and data with the corporate infrastructure in a safe and reliable manner. This session will discuss several real-world use cases.

Speaker(s): Eric Jensen, Oracle, Principal Product Manager
Greg Rekounas, Rekounas.org, Oracle Mobile Consultant
Event: JavaOne and Oracle Develop
Stream(s): ORACLE DEVELOP, DEVELOP

I am quite exited about going this year. Oracle Mobile Server is in the process of changing the client database from Oracle Lite Database to the Oracle Berkeley Database. I will be testing out some of these features and hope to have a how-to post about getting your synchronization working with Berkeley DB soon.

Oracle Database Lite client sunsetting announcement [ID 1124003.1]
Applies to:
Oracle Lite - Version: 10.0.0.0.1 to 10.3.0.3.0 - Release: 10.0 to 10.3
Information in this document applies to any platform.
What is being announced?
We are announcing changes to the Oracle Database Lite product.

Some components will be shifted to maintenance mode, while others will continue to be actively developed and enhanced.

The Oracle Lite Client Database, as well as Branch Office and the Web-to-Go components, will be moved to maintenance mode.
The core underlying framework, including the Mobile Sync Client and Server, Device Manager and the Mobile Device Workbench, will continue to be actively developed.

Oracle Database Lite will be removed from the pricelist at the end of Q2FY11 (end of November 2010).
What do you need to do?
The primary product Oracle recommends to replace the Lite Client Database is the Oracle Berkeley Database, which is a fast, highly scalable, embeddable, transactional database.

Berkeley DB 11.2.5.0.21 has been enhanced with SQL support (SQLite SQL), in addition to its traditional key/value store interface. This is for situations where the customer requires a lightweight embedded database, with the ability to synchronize with the Oracle Database.

In situations where a multiuser database server is required, such as in existing Branch Office configurations, Oracle Standard Edition One is the recommended alternative. However, these products do not overlap 100%, so some application changes may be required.

In cases where customers are using Web-to-Go on the client side to run JAVA Servlets, the customer will need to replace Web-to-Go with a Servlet container of their choosing. Oracle is not offering an official mobile Servlet container at this time.

Who to contact for more information?
Oracle Database Lite will continue to be supported by the Oracle Support Team. For release 10.3, Premier Support will continue until December 2012. After that, Extended Support will continue until the end of 2015.

During both the Premier and Extended Support phases, Oracle Sustaining Engineering will provide program updates, fixes, security alerts, and critical patch updates to Oracle Database Lite customers. As with all Oracle products, support is available indefinitely to customers who purchase Lifetime Support.

Those customers will continue to have access to Oracle’s repository of security alerts, patches, solutions, and other documentation. Lifetime Support will be available beyond 2015, for as long as necessary.

For more information regarding the Oracle Support Policy, please refer to the Technical Support Policies page:
http://www.oracle.com/support/policies.htm

What do you do?  You could tune the existing queries for your publication items to improve sync and MGP performance.  Of course, there is always that poorly written and timed PL/SQL that the junior guy wrote that is inserting/deleting 1 million records in one of your core tables that you are synchronizing to your application, and just when you notice this happening along with syncing or MGP, you notice transactions in C$ALL_CLIENT_ITEMS is blocking all kinds of sessions.  Oracle recommends setting the following in webtogo.ora

SKIP_INQ_CHK_BFR_COMPOSE=NO
DO_APPLY_BFR_COMPOSE=NO

I prefer going to queue based synchronization for situations like this.  Why?   The first things is that it removes triggers on those tables that are usually affected by the blocking locks.  Secondly, if you have bulk operations on a table, the MGP LOG process can get bogged down with logging all the transactions and you often see deadlocks when this happens not to mention blocking locks if the deadlock doesn’t cancel out the MGP process quickly enough.

I am assuming if you are reading this, you are probably familiar with the Mobile Workbench and have created your publication items via that mechanism and felt really good about the fact that you don’t have to write all kinds of stored procedures to perform your synchronizations.  Well, roll up your sleeves, because you will have to write some PL/SQL to get a queue-based refresh working.  In the mobile development kit, there is a tutorial on how to go about creating a queue-based item (Location %ORACLE_HOME%\Mobile\Sdk\samples\Sync\win32\QBasedPI\)

There is a readme.txt in that folder.  I am not going to repost the tutorial, but I will talk about the aspects you should be aware of.  The tutorial basically give a complete-refresh example. This would not be the best example for most applications as there are also bi-directional publication items that you need to worry about.  The real piece of the code you should be concentrating on is the DOWNLOAD_INIT within the package.  This is your download logic.  Your logic should contain the following logic:

• handles physical deletes
• handles inserts
• handles update
• handles logical deletes

Their example only handles inserts.  If you want your publication item to perform incremental syncs, you will need to have a mechanism in that table that indicates records that need to be updated, inserted, or deleted. Here is a template of the mechanism I use.  In our tables, we have an AUDIT_DATE field.  A timestamp or date field is really useful in determining if a record has been updated.  Of course, you may need a trigger on the table or trust those junior developers to have code in place to update that AUDIT_DATE field.

The physical delete:
DELETE CTM$CTM$<TABLE_NAME>
WHERE CLID$$CS = CLIENTID AND DMLTYPE$$ = 'D';

The insert logic:
INSERT INTO CTM$<TABLE_NAME>(CLID$$, FIELDS1, FIELDS2, DMLTYPE$$, TRANSID$$)
SELECT CLIENTID, FIELDS1, FIELDS2, 'I', CURR_TRAN FROM <TABLE_NAME>
WHERE NOT EXISTS (SELECT 'X' FROM CTM$<TABLE_NAME>
WHERE <MATCH PRIMARY KEYS HERE>)

The update logic:
UPDATE CTM$<TABLE_NAME>

The logical delete:
UPDATE CTM$<TABLE_NAME>
SET TRANID$$ = CURR_TRAN,
DMLTYPE$$ = ‘D’
WHERE AUDIT_DATE < TO_CHAR( ADD_MONTHS( SYSDATE, -6 )) AND CLID$$CS = CLIENTID;

Now, in my example, I just keep 6 months of data on the client. At the end of the day, you can decide all aspects of synchronization. Customize the synchronization to fit your business needs.

Lets review the way you create a auto-increment field in Oracle:

//Step 1:
CREATE TABLE TEST_TABLE (
COL1 NUMBER,
COL2 VARCHAR2(20),
CONSTRAINT TEST_TABLE_PK PRIMARY KEY (COL1)
);



//Step 2:
CREATE SEQUENCE TEST_SEQ
START WITH 1
INCREMENT BY 1;



//Step 3:
CREATE TRIGGER TEST_TRIGGER
BEFORE INSERT ON TEST_TABLE
FOR EACH ROW
BEGIN
SELECT TEST_SEQ.NEXTVAL INTO :NEW.COL1 FROM DUAL;
END;


And we are done.

Now here are the steps for doing it in Oracle Lite:

//Step 1: Create and Compile the Java Code.  Call the Java file JavaTrigger.java.  You may also have to compile using JDK 1.4 as even Oracle 10g is known not to support 1.5 yet.
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JavaTrigger {
   public static void autoIncrement(Connection conn, int newNum[]) throws SQLException {
      try {
         Statement stmt = null;
         ResultSet rs = null;
         stmt = conn.createStatement();
         rs = stmt.executeQuery(”SELECT TEST_SEQ.NEXTVAL FROM DUAL”);
         if (rs.next()) {
            newNum[0] = rs.getInt(1);
         }
      } catch (SQLException e) {
         System.err.println(e.getMessage());
      }
   }
}


//Step 2: Load the file into the database
CREATE JAVA CLASS USING BFILE ('C:\OracleLiteJava\StoredProcedure\Sample\classes\','JavaTrigger.class');



//Step 3: Create a Stored Procedure in the database
CREATE OR REPLACE PROCEDURE AUTO_INCREMENT(NEW_ID IN OUT INT) AS LANGUAGE JAVA NAME 'JavaTrigger.autoIncrement(java.sql.Connection, int[])’;



//Step 4:
CREATE OR REPLACE TRIGGER TEST_TABLE_INSERT_TRIG BEFORE INSERT ON TEST_TABLE FOR EACH ROW AUTO_INCREMENT( NEW.COL1);



//Working Example:
SQL> INSERT INTO TEST_TABLE( COL2) VALUES ('GREG');
1 row(s) created
SQL> DIR TEST_TABLE;
COL1 | COL2
-----+-----
6340 | GREG


For more documentation on Stored Procedures in Oracle Lite, check out the online documentation here.

How do you find the right person.

• Obviously ask them how many projects they have worked on with Oracle Lite or how many years they have working with the product.  Standard question for any technology.
• Ask them the size and scope of the project (users/publications/publication items).
• What technologies within Oracle Lite did they use?  Win32, WinCE, OC4J, Webtogo, Symbian, etc.
• For the more advanced questions, you could ask them about the polite.ini and the webtogo.ora files and what are their functions.
• Asked them if they have used Partition Maps, Shared Maps, Cached Publication Items.  If they have used these, then there is a good chance that they have worked on a system with considerable amounts of data and that they probably have performed query tuning.
• Ask them if they have used CONSPERF and what is it’s function.
• If they have used Oracle Application Server (OAS), then ask them if they have set up a farm and to describe the process.  You may want to ask them what is the function of OPMN, but it’s not as important if they don’t know.  This question will demonstrate their expertise with OAS (But I think Oracle Lite will be using Weblogic starting 10.3.0.3 release for the server).

If you do have an IT project that requires Oracle Lite as your solution, finding a good Oracle Lite resource with experience will be difficult but rewarding.

Here is a picture of a test scenario we had set up. We had 10 laptops and they were synchronizing Webtgo-OC4J and Win32. They were all going through the same router and I think 10 out of 10 succeeded.

Your third option for testing concurrency is by contacting an Oracle Lite guru He might be able to give you a hand with your performance testing.

1. Stopped the server
2. Installed the patch
3. Tried to log into mobile manager
4. Got the following error:
WTG-10118: Mobile Server is not connected to the Repository
WTG-10117: Please contact your system administrator

To find the problem I went to the readme of the patch that stated that the web.xml file might get changed during the install. So, I opened the file and the fix is the following:

Find your web.xml file

<ORACLE_HOME>/mobile/server/admin/repository/webtogo/WEB-INF/web.xml
or
<ORACLE_HOME>/j2ee/mobileserver/applications/mobileserver/webtogo/WEB-INF/web.xml
or
<ORACLE_HOME>/mobile_oc4j/j2ee/mobileserver/applications/mobileserver/webtogo/WEB-INF/web.xml

Modify the line in the file from:

<param-value>%ORACLE_HOME%\mobile\server\bin\webtogo.ora</param-value>

to

<param-value>/export/home/oramobile/mobile/server/bin/webtogo.ora</param-value>

The README.TXT tells me to go into my ./patch_storage/6630384/….. directory.  But I couldn’t find it.  So, if you find yourself in the same situation that I was in, the solution has been posted.