There are two primary considerations for deploying your UltraLite solution:

• Deploying the files that provide UltraLite functionality (the runtime files)
• Deploying the UltraLite database file or files (used by the runtime files and containing application data)

Deploying the runtime files depends primarily on the language used to develop your solution (C/C++, .NET, M-Business, Objective C) and whether the UltraLite engine is required. The UltraLite engine is required if:

• multiple processes access the same database file at potentially the same time (by "same time" we mean multiple processes have connections open to the same database at the same time).
• Central Administration is used to manage the UltraLite application database.

The alternative to the UltraLite engine is the UltraLite "in-process" runtime, which can be simpler to deploy and provide improved data access performance because process boundaries are not crossed (however it means that multiple applications cannot have connections open to the same database at the same time). The engine is available on:

The engine executable can be found in %sqlany%\ultralite\<platform>\<chip>\.... In some cases, there is a version of the engine under <chip>_dev (for example x86_dev). This version of the engine contains development-time logging functionality that can be used to diagnose problems on platforms where it's difficult to debug. The logging output is intended to be used by Sybase engineers rather than customers. For production systems, use the version of the engine that is NOT in the _dev directory.

If your application uses the UltraLite engine, then you need to concern yourself with deploying all the files required by the engine, and all the files required by the client using it. The client files are programming-language specific. The engine files are independent of the programming language.

The engine consists of an executable (uleng12) and optional shared libraries that contain specific features. See Deploy multiple UltraLite applications with the UltraLite engine and UltraLite Engine utility (uleng12) for further information.

The client files are closely associated with the application, and depend on the programming language of the application.

When building a C/C++ application, you can either link all the UltraLite client code into your application or, if you are targeting Windows or Windows Mobile, you can load the client code dynamically at runtime. Linking the UltraLite client code into your application means you do not need to deploy any additional files with your application and the UltraLite engine. To link all the UltraLite client code into your application, link with:

If you want to load the UltraLite client code dynamically at runtime, link your application code with:

When building a .NET application using the UltraLite client, be sure to deploy ulnetclient12.dll along with your .NET assemblies. See System requirements and supported platforms for more information on required files for deployment.

When building a C/C++ application that does not use the UltraLite engine, you can either link to a static UltraLite runtime library (this makes sure all the UltraLite code is linked into your application) or, on Windows and Windows Mobile, you can link to an import library and load the UltraLite runtime code dynamically when the application starts. For Windows and Windows Mobile, if you link to the import library, then you need to deploy ulrt12.dll along with your application. For more information on compiling and linking your application, see Developing applications using the UltraLite C++ API. If you are linking with the static runtime library, there are no additional files to deploy with your application.

Initially installing your UltraLite solution on a device is a required step so that the device can be continuously maintained.

• Using MobiLink file transfers
• UltraLite clients
• Using ActiveSync with UltraLite on Windows Mobile
• Deploying UltraLite schema upgrades
• ALTER DATABASE SCHEMA FROM FILE statement [UltraLite]