sqlite - How To Compile

Not logged in

• Honeypot
• Browse
• Home
• Login
• Reports
• Search
• Ticket
• Timeline
• Wiki

• Contents
• Diff
• Text

* CodeWarrior: Notes on compiling on MacOS using CodeWarrior *

(see also the MacOSX command line instructions below)

If the "configure" script does not work for you, then you might have to compile manually. Fortunately, this is easy to do. First download the preprocessed source code from http://www.sqlite.org/sqlite_source.zip. This archive contains a set of C source and header files that are ready to be passed to a C compiler. To build the library, just compile all of the files.

Note that the files "shell.c" and "tclsqlite.c" are special and do not belong in the SQLite library proper. "shell.c" is used to build the "sqlite" shell program and "tclsqlite.c" is the TCL bindings for SQLite. You may want to omit both of these files when you build the library.

For example, I was able to compile SQLite for HPUX as follows:

  unzip sqlite_source.zip
  rm tclsqlite.c
  for i in *.c; do c89 -O -c $i; done
  rm shell.o
  ar cr libsqlite.a *.o
  ranlib libsqlite.a
  c89 -o sqlite shell.c libsqlite.a

---

DJGPP (32 bit, protected memory DOS)

libsqlite.a and sqlite.exe may be made for djgpp in a similar way as with HPUX above. it compiles and works out of the box, with the following limitations:

1. temporary files are not removed upon database close (journal file).

2. files created by sqlite automatically will be correctly created only if lfn is enabled. otherwise, lacking the journal file, the database will be open read-only.

my diffs are fixing both problems, and make sqlite work very well on djgpp.

to avoid overload of this page, i have attached patches to sqlite development tickets. each patch applies for a certain sqlite version, as follows:

for sqlite 2.8.6: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=524

for sqlite 2.8.11: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=572

for sqlite 2.8.13: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=717

for sqlite 2.8.14: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=822

for sqlite 2.8.15: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=833

for sqlite 3.0.7: diff attached at http://www.sqlite.org/cvstrac/tktview?tn=930

please compile as follows:

  unzip sqlite_source.zip
  rm tclsqlite.c
  for i in *.c; do gcc -c $i; done
  rm shell.o
  ar crs libsqlit.a *.o
  RDLN_DEF=-DHAVE_READLINE=1 #if you wish to use
  gcc -DSQLITE_DISABLE_LFN $(RDLN_DEF) -c shell.c
  RDLN_LIBS=-lreadl -lhisto
  gcc -o sqlite.exe $(RDLN_LIBS) shell.o libsqlit.a

it will also do no harm to incorporate it in the main sqlite distribution.

i'm sorry it has not been evident until now, so i am explicitly including the following copyright disclaimer, as required by sqlite author:

The author or authors of this code dedicate any and all copyright interest in this code to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights this code under copyright law.

alex <alexbodn@012.net.il>

DJGPP: http://www.delorie.com/djgpp

---

Microsoft Visual Studio.NET

See HowToCompileWithVsNet.

---

Visual C++ Toolkit 2003 combined with GNU Make/MSYS

For the sqlite-source-3_0_8.zip there's a makefile which can be used with MSYS combined with Visual C++. This makefile can be found here: http://www.elemental-programming.org/epwiki/SQLID- SQlite%20Makefile

---

MSVC and SQLite DLL

Creation of an import library from the sqlitedll.zip (http://www.sqlite.org/sqlitedll.zip) for MS Visual C++ is achieved by the following command:

LIB /DEF:sqlite.def

This makes the files sqlite.lib and sqlite.exp files. The sqlite.lib can then be used to link your programs against the SQLite DLL.

---

Crosscompile linux x86 -> linux arm

1. Install skiff toolchain or similar, make shure you have arm-linux-gcc in your PATH.

2. Unpack sqlite sources and create a directory sqlite-arm in the same dir.

3. Edit configure script in the sqlite dir and comment following lines out as shown - have fun finding them ;-)

  if test "$cross_compiling" = "yes"; then
   { { echo "$as_me:12710: error: unable to find a compiler for building build tools" >&5
   echo "$as_me: error: unable to find a compiler for building build tools" >&2;}
   { (exit 1); exit 1; }; }
  fi

  . . .

  else
    test "$cross_compiling" = yes &&
    { { echo "$as_me:13264: error: cannot check for file existence when cross compiling" >&5
    echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
    { (exit 1); exit 1; }; }

  . . .

  else
   test "$cross_compiling" = yes &&
   { { echo "$as_me:13464: error: cannot check for file existence when cross compiling" >&5
  echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }

  . . .

  else
   test "$cross_compiling" = yes &&
   { { echo "$as_me:13490: error: cannot check for file existence when cross compiling" >&5
  echo "$as_me: error: cannot check for file existence when cross compiling" >&2;}
   { (exit 1); exit 1; }; }

4. Save the configure script, change into the build directory you created and call the edited configure script from the sqlite directory by using the following option:

../sqlite/configure --host=arm-linux

5. After that configure should have created a Makefile and a libtool script in your build directory. Open the Makefile using your favorite text editor and edit the following line:

BCC = arm-linux-gcc -g -O2

to see:

BCC = gcc -g -O2

6. run make Now you should find a ".libs" directory in your build directory containing sqlite shared object files, like libsqlite.so.

Source (somewhat altered): http://www.kecher.de/howtos/SQLite-JDBC-Howto.html

---

Win32 recompile with mingw32/msys

For a makefile which works with 3.0.7, see ticket #931. No need for MSYS.

	1. Download mingw from www.mingw.org
	2. Get the sqlite3 source tree
	3. Get the makefile attached to #931
	4. Make sure you have 'gawk', 'sed' and 'grep' (call grep ggrep, or edit the makefile).  Also get upx 
and install it.
	5. Type 'make'. 
	6. Optionally type 'make doc'.  This requires you to have installed tcl, also available from 
www.mingw.org.

If you don't want to get and install upx, type 'make sqlite3.exe'.

When you are done, you will have a sqlite3.exe and a sqlite3.dll. The EXE requires the DLL.

---

Older instructions for mingw, good as of sqlite source 2.8.13:

1. Download mingw from www.mingw.org

2. Download msys from www.mingw.org

3. Install mingw to c:\mingw and msys to c:\msys N.B.! Need to override msys installer's default to install in c:\mingw DO NOT co-mingle msys binaries with mingw's -- see: http://www.mingw.org/mingwfaq.shtml#faq-usingwithmsys

4. Download the FULL sqlite source (http://www.sqlite.org) and extract it to desired location (e.g., c:\mysqlite). This will create, among other entries, a src subdirectory, (e.g., c:\mysqlite\src).

5. Create a sibling build directory (e.g., c:\mysqlite\build)

6. Start the msys.bat (in c:\msys), which opens msys shell window, and cd to sqlite build directory. Invoke (msys's) ../sqlite/configure. This generates a Makefile in the build directory.

7. Invoke mingw32-make to compile the resulting Makefile. (make isn't used anymore - see http:// www.mingw.org/mingwfaq.shtml#faq-mingw32-make.exe)

8. Find within the source distribution a file called sqlite.def. Copy it to the build directory.

9. Invoke: dllwrap --dllname sqlite.dll --def sqlite.def *.o (or if this doesn't work, dllwrap --def sqlite.def -v --export-all --driver-name gcc --dlltool-name dlltool --as as --target i386-mingw32 -dllname sqlite.dll -lmsvcrt *.o)

9. strip sqlite.dll

10. Ready.

---

Win32 recompile with borland c++ builder

1. Download preprocessed source from http://www.sqlite.org/sqlite_source.zip

2. Unzip the source to a project directory, e.g. C:\sqlite

3. Fire up your borland c++ builder and create a new dll project, plain C without mfc or something like that

4. Save the project as (e.g.) C:\sqlite\sqlite.bpr

5. Add the sqlite source files from c:\sqlite to the project

6. Remove the unit1.* files from your project

7. Even if .def files are not the clean way, it will be easier than rewriting the sourcecode. Create the file sqlite.def with the following content and add it to the project:

   LIBRARY sqlite.dll
   EXPORTS
   sqlite_open    = _sqlite_open
   sqlite_close   = _sqlite_close
   sqlite_exec    = _sqlite_exec
   sqlite_last_insert_rowid   = _sqlite_last_insert_rowid
   sqlite_error_string   = _sqlite_error_string
   sqlite_interrupt   = _sqlite_interrupt
   sqlite_complete   = _sqlite_complete
   sqlite_busy_handler   = _sqlite_busy_handler
   sqlite_busy_timeout   = _sqlite_busy_timeout
   sqlite_get_table   = _sqlite_get_table
   sqlite_free_table   = _sqlite_free_table
   sqlite_mprintf   = _sqlite_mprintf
   sqlite_vmprintf   = _sqlite_vmprintf
   sqlite_exec_printf   = _sqlite_exec_printf
   sqlite_exec_vprintf    = _sqlite_exec_vprintf
   sqlite_get_table_printf   = _sqlite_get_table_printf
   sqlite_get_table_vprintf   = _sqlite_get_table_vprintf
   sqlite_freemem   = _sqlite_freemem
   sqlite_libversion   = _sqlite_libversion
   sqlite_libencoding   = _sqlite_libencoding
   sqlite_changes   = _sqlite_changes
   sqlite_create_function   = _sqlite_create_function
   sqlite_create_aggregate   = _sqlite_create_aggregate
   sqlite_function_type   = _sqlite_function_type
   sqlite_user_data   = _sqlite_user_data

   sqlite_aggregate_context   = _sqlite_aggregate_context
   sqlite_aggregate_count   = _sqlite_aggregate_count
   sqlite_set_result_string   = _sqlite_set_result_string
   sqlite_set_result_int   = _sqlite_set_result_int
   sqlite_set_result_double   = _sqlite_set_result_double
   sqlite_set_result_error   = _sqlite_set_result_error
   sqliteMalloc   = _sqliteMalloc
   sqliteFree   = _sqliteFree
   sqliteRealloc   = _sqliteRealloc
   sqlite_set_authorizer   = _sqlite_set_authorizer
   sqlite_trace   = _sqlite_trace
   sqlite_compile   = _sqlite_compile
   sqlite_step   = _sqlite_step
   sqlite_finalize   = _sqlite_finalize

8. Go to Project|Options|Directories/Conditionals. Add 'NO_TCL' to Conditional defines

9. Fire up the compiler.

10. Ready.

---

Mac OS X build

I used the standard Unix build instructions...

  $ tar xzf sqlite.tar.gz       Unpacks into directory named "sqlite" 
  $ mkdir bld                   Create a separate build directory 
  $ cd bld
  $ ../sqlite/configure --disable-shared
  $ make                        Builds "sqlite" and "libsqlite.a" 
  $ make test                   Optional: run regression tests 

But don't forget the implied

  $ make install

step! (if you are installing in /usr/local you might have to do this as root, e.g.: "sudo make install")

The --disable-shared option is required for Mac OS X because libtool is busted and will generate an invalid shared library.

The usability of the sqlite shell is greatly enhanced if you have readline support. If you install GNU readline first, sqlite will link to it automatically. Note that sqlite doesn't search in the fink (/sw) hierachy by default, so if you want to use fink readline you'll probably have to use compilation flags to point the configure script to /sw/lib and /sw/include/readline as well as adding /sw/lib to the DYLD_LIBRARY_PATH environment (WARNING: NOT TESTED!). Instead of doing this it might be easier just to install readline in the default location under /usr/local (readline 5 installs without a hiccough using the regular .configure; make; make install).

---

* Under AIX 4.3.3 with gcc *

  fmedico <at> yahoo.com

  mkdir sqlite
  cd sqlite
  unzip ../sqlite_source.zip
  rm tclsqlite.c libsqlite.a sqlite 2> /dev/null
  for i in *.c; do gcc -g -O2 -c $i; done
  rm shell.o
  ar cr libsqlite.a *.o
  ranlib libsqlite.a
  gcc -o sqlite shell.c libsqlite.a

---

Cygwin

1. Run configure

2. edit src/os.h, go to ~ line 90 (behind the #ifndef OS_UNIX block) and add ala mingw solution above

   #define OS_WIN 1
   #define OS_MAC 0
   #define OS_UNIX 0

A similar change has already been checked into the CVS tree and should appear with release 2.8.6.

In 2.8.13 an extra slash passed to libtool caused me some trouble installing on cygwin. Removing each occurance of $(DESTDIR)/ from Makefile did the trick. There were eight, all in the install section. This var is handy for distributions, so probably don't want to remove.

---

Boost.Jam

This assumes you're a C++ type who likes http://boost.org

Haven't gotten into the tcl interface, so the C_SOURCES variable bears

inspection.

Acquire boost, and boost jam.

Navigate to <boost path>/libs

mkdir sqlite

cd sqlite

mkdir src

mkdir build

cd src

<unzip the sqlite source code here>

cd ../build

<save the following text as Jamfile>

# (C) Copyright 2002. Permission to copy, use, modify, sell and

# distribute this software is granted provided this copyright notice appears

# in all copies. This software is provided "as is" without express or implied

# warranty, and with no claim as to its suitability for any purpose.

#

#

# Boost.sqlite build

#

# To run all tests quietly: jam test

#

# Declares the following targets:

# 1. sqlite, a library to be linked with all

# Boost.sqlite modules

#

# declare the location of this subproject relative to the root

subproject libs/sqlite/build ;

# Base names of the source files for libboost_sqlite

C_SOURCES = attach auth btree btree_rb build

            copy   delete   expr    func     hash

            insert main     opcodes os       pager

            parse  pragma   printf  random   select

            table  tokenize trigger vdbe     where

            update util     vacuum  

          ;

EXE_ONLY = shell

          ;

dll sqlite : ../src/$(C_SOURCES).c

    : <sysinclude>$(BOOST_ROOT) 

    : debug release 

    ;

lib sqlite : ../src/$(C_SOURCES).c

    : <sysinclude>$(BOOST_ROOT) 

    : debug release 

    ;

exe sqlite : ../src/$(C_SOURCES).c ../src/$(EXE_ONLY).c

    : <sysinclude>$(BOOST_ROOT) 

    : debug release 

    ;

Now you can just build sqlite along with the rest of boost. Tested on VC7.1 and GCC 3.3.1. Boost jam builds debug, release, static, and dynamically linked targets with a lack of fuss and bother.

---

AIX 5.2 with large file support

I used the IBM compiler xlc with specific cflags to build SQLite 2.8.7. AIX uses a slightly different define to enable 64 bit I/O in the system headers _LARGE_FILES. SQLite expects _LARGE_FILE, so I define both flags. The final two flags are -q32 which builds as a 32 bit application and -qlonglong, which enables the long long datatype.

Here are the steps I used:

   ./configure

edit Makefile, change the TCC macro:

     TCC = xlc -q32 -qlonglong  -D_LARGE_FILE=1 -D_LARGE_FILES=1 -DUSE_TCL_STUBS=1 -O2 
-DOS_UNIX=1 -DOS_WIN=0 -DHAVE_USLEEP=1 -I. -I${TOP}/src

   make

Tom Poindexter 2003-12-17

---

Building a statically linked libtclsqlite

I use SQLite as part of a Starkit-based application. See http://equi4.com/tclkit.html and http:// equi4.com/starkit.html

In assembling a Starkit for Linux, one problem is incompatibility between different verions of glibc (e.g. RedHat 7.2 using glibc2.2, RedHat 8.0 using glibc2.3). There is a static build of tclkit for linux that avoids this problem by statically linking all libraries. I wanted the SQLite extension for Tcl to have the same feature.

Here are steps to build a statically linked Tcl extension:

First, make sure that the -DUSE_TCL_STUBS=1 macro is defined in your TCC makefile macro. We will be linking manually, so if using gcc, get the path to the libgcc.a for your installation:

   gcclib=`gcc -print-libgcc-file-name`

Add the following lines to your SQLite Makefile:

   echo '' >>Makefile
   echo 'static-libtclsqlite.so:       tclsqlite.lo $(LIBOBJ)' >>Makefile
   echo "          ld -shared -soname libtclsqlite.so  -o libtclsqlite.so *.o -L/usr/local/lib -ltclstub8.4  
-static -ldl -lm -lc  $gcclib" >>Makefile

Note that a tab should be inserted a the first character of the second line. Adjust your path to your Tcl install if not /usr/local/lib in order to find libtclstub8.4.a. Now build:

   make
   make static-libtclsqlite.so

Tom Poindexter 2003-12-17

---

[ ULTRIX/VAX 4.4 ]

I successfully got Sqlite 2.8.13 to compile under ULTRIX/VAX 4.4 (4.x should work fine, not sure about earlier versions).

SQLite would NOT compile with VAX C, I had to install GCC and GNU make. There are binary packages out there for GCC 3.0.4 and GNU MAKE floating around on the net.

After setting the CC and CPP environment variables to the location of GCC (in my case it was /usr/ freeware/gnu-tools/vax/bin/gcc) and the preprocessor, SQLite compiled out of the box, just run configure, then GNU make (stock BSD make will NOT work!) and it will chew on it for a couple hours (hey, it's still a VAX), and in theory you should have working Ultrix SQLite.

NOTE: Remember, Ultrix has no support for shared libraries, if you want to use SQLite in an application, you have to compile sqlite in as a static library. This goes for TCL as well, you have to recompile TCL with libsqlite.la and libtclsqlite.la compiled smack inline.

No, I don't have any benchmarks unfortunately. It would be funny to benchmark SQLite against the University Ingres QUEL DBMS that ships with Ultrix on the UNSUPPORTED software distribution on the CD/TK50 tape/whatever else Ultrix shipped on.

My configuration:

DEC VAXserver 3100 m30 w/ 16MB/RAM, 1.6GB disk space. ULTRIX 4.4/VAX GCC 3.0.4 GNU MAKE

Have fun.

Kevin D. Ogden 19 APR 2004 E-Mail: ogdenk REPLACE-WITH-CORRECT-CHARACTER expressautoservice.com

---

Compiling SQLite with MS VC++ 5 for C newbies

This is a step-by-step procedure for those like me who wish to recompile SQLite and the "VB Wrapper" by Steve O'Hara to make this DLL VB-friendly. Note that I don't remember much from my C days, so should any kind soul spot any error, please add your corrections:

1. Install MS VC++
2. File | New | Projects : Choose Win32 DLL, and give a name to your new project. It will be saved in its own subdirectory under "\Program Files\DevStudio\MyProjects\". Choose the name carefully as it will be the one used to generate the DLL
3. Unzip the SQLite source code into this directory (Caution: I understand that there are two versions of the source code. One is the most generic, ie. not meant for a particular OS, while one source package has been massaged, ready to be compiled by MS VC++. Choose the latter)
4. Project | Add to project | Files, navigate to the folder where your project lives and now contains the SQLite source files, and select all its C files to have them added to your project (Note: To remove a file from a project, select it once with the mouse, and hit the DEL key. There is no option in the menu, either the application's or the pop-up's)
5. If you have no use for TCL (a scripting language), remove tclsqlite.c
6. Build | Set Active Configuration, and select "My project - Win32 Release" so we generate a plain DLL, with no debug infos
7. If you wish to add version information so you get a Version tab when right-clicking on the DLL in Windows Explorer, select Project | Add to project | New : Resource Script. A clear-text res.rc is added to the project that you can edit to include version information (I haven't found how to have the version be incremented automatically.) Note that this version info embedded by VC++ is independent from the version info returned by sqlite_libversion(), ie. don't worry about the fact that the former is a four-digit number, while the latter uses three
8. Build | Rebuild All. You'll see plenty of warnings, but if all goes well, you should now have a DLL in a Release/ subdirectory in your project directory

If you wish to use Steve O'Hara's free VB wrapper ("VB Wrapper", ex-psvbutls32 in the Files section of the now dead SQLite mailing list over at Yahoo), just add its source file pssql.c and its export file pssql.def to your project, edit the DEF file so that the LIBRARY line matches the name of your DLL (or you'll get a warning), and build the DLL.

Note that pssql.c assumes that the SQLite source code is located in a sqlite/ subdirectory, so either create a subdirectory to host the SQLite source files, or edit this file to have all the C files in the same directory. If the DEF file is missing, you'll get ""Runtime Error 453 Can't find DLL entry point PSVBUTLS_VersionDB in mysqlite.dll" when calling any of the wrapper's exported functions.

To check that this DLL works fine, create a new project in VB, add the following code in a form, and hit F5:

	Private Declare Function PSVBUTLS_VersionDB$ Lib "mysqlite.dll" ()

	Private Sub Form_Load()
	    Me.Caption = "SQLite version " & PSVBUTLS_VersionDB$
	End Sub

Voila! :-)

Fred.

---

For 3.0.8 : On Solaris - to do what Tom did above - to create a libtclsqlite3.so without dependencies. The include and lib paths are somewhat hosed in the makefile - it somehow seems to need a source installation (/unix in path). I changed this in the Makefile:

   TCL_FLAGS = -I/usr/local/tcl/8.4.5/include -DUSE_TCL_STUBS
   LIBTCL    = /usr/local/tcl/8.4.5/lib/libtclstub8.4.a -ldl -lm

Then:

   % make libtclsqlite3.la

Copy the last line that is used to build the LA object. Remove all objects and libs and instead use *.o

   % gcc <flags including -o> .libs/*.o /usr/local/tcl/8.4.5/lib/libtclstub8.4.a  <other flags>

if you get an error remove .libs/tclsqlite3-sh.o

VI [http://mini.net/tcl/8740]