SQLiteStudio is a streamlined and comprehensive SQLite database manager that makes it easy for you to manage and edit databases with the help of its useful and powerful set of tools. Read reviews, compare customer ratings, see screenshots, and learn more about Valentina Studio. Download Valentina Studio for macOS 10.7.0 or later and enjoy it on your Mac. Extension for Visual Studio - SQLite / SQL Server Compact Toolbox extension for Visual Studio. This extension adds several features to help your embedded database development efforts: Scripting of tables and data, import from SQL Server and CSV files and much, much more. Download SQLite Management Studio for free. SQLite Management Studio is a SQLite GUI tool for managing all of your SQLite databases. It is based on the Qt Framework, thus making it available for all major commercial operating systems. SQLite documentation for details on what are SQLite runtime loadable extensions. To load SQLite extension into SQliteStudio database connections, open Extension Manager: Extension manager window is similar to Collation editor window.
- Installation and running
- Basics
- Creating new database
- Managing database list
- Executing SQL queries
- Editing the data
- Creating and editing tables
- Column dialog
- Creating and editing indexes
- Creating and editing triggers
- Configuration dialog
- SQLiteStudio updates
- Advanced usage
- Troubleshooting
Supported platforms
Platform | Status | Binaries provided | Notes |
---|---|---|---|
Windows (32bit) | Supported | Yes | |
Windows (64bit) | Supported | Yes | |
Linux (32bit) | Supported | Yes | |
Linux (64bit) | Supported | Yes | |
Mac OS X (ix86 64bit) | Supported | Yes | This includes most of the modern Macs, see http://support.apple.com/kb/ht3696 for details. |
Mac OS X (ix86 32bit) | Not supported | No | |
Mac OS X (PowerPC) | Not supported | No | |
FreeBSD | Should work, not tested | No | |
Solaris | Should work, not tested | No | |
Other operating system | Not supported | No |
Installing binary package
Installing from source code
See Compiling application from sources.
Creating new database
You can create new database in three ways:
- Click on toolbar button:
- Click on main menu entry:
- Right-click on database list and pick entry from context menu:
Then the database dialog will appear:
Click on the browse button:
You will see filesystem browsing dialog (this may look different on various operating systems):
In this dialog go to directory where you want to create your database and type in the file name for your database (on the image above it's 'test.db'). Click 'Save'. Now the database dialog has file name and database name filled in. You can change the name to whatever you want (in which case you have to disable the checkbox on the right hand side), or just leave it as it is.
The database name is just symbolic name, an alias used by SQLiteStudio to present database in the list. You can pick any name you want, it just has be unique in context of databases already added to SQLiteStudio.
You can press 'Test connection' to make sure that your database file can be created in specified localisation (in regards of directory permissions, free space, etc). If everything is okay, than you will see green icon next to it:
If there was any problem, the red icon will appear.
You can now press 'Ok' to create the database. You will see it in the databases list on the left:
Double-click to open it:
Permanent vs transient database
You may have noticed the 'Permanent' check in the database dialog:
When this option is checked, then the database is added permanently to SQLiteStudio. This means that when you close SQLiteStudio and start it again, the database will remain on the list.
If this option is not checked, then the databases will disappear from the list after SQLiteStudio was restarted.
Using existing database
Adding an existing database to the list is very similar to creating new database.
Repeat steps from above, util you see database dialog:
Then you click (just like before) on browse button:
In the file browsing dialog pick an existing database file:
Then click 'Save' and 'Ok' in next dialog and your database will be added to the list. You can double-click on it to open it:
Alternatively you can use drag&drop mechanism: drag database file from your file manager and drop it onto the database list, then confirm the database dialog.
Managing database list
Editing database details
You can edit database details at any moment. Just right-click on it and pick 'Edit database' from context menu. The standard database dialog will appear.
Changing database's name is allowed as far, as the new name is unique across all databases being currently on the list.
The database name is just symbolic name, an alias used by SQLiteStudio to present database in the list.
When changing database file path, it will mean that under the same name you will access the new database file. It will not copy nor move the old database file to new location.
When editing database details it's not possible to change it's type (SQLite2, SQLite3, or any other), because this is allowed only when creating new datababase. If you want to convert one SQLite version into another, use database conversion dialog.
Organizing database list
You can move databases up and down with mouse 'drag & drop'. You can create virtual 'directories' where you can group databases. It helps maintaining big number of databases on the list.
To create a group, right-click on the databases group and pick 'Grouping' → 'Create group'. Then you can drag & drop databases into that group:
Groups can be nested.
If you right-click on the database and pick 'Create group', then the clicked database will be automatically moved into the group after the group was created.
Deleting database from the list
To delete database from the list, select the database and either:
- right-click on it and pick 'Remove database',
- or press 'Delete' from the keyboard.
You will be asked for confirmation, before the database is actually removed from the list.
Deleting database from the list does not delete database file! It only removes it from the list of databases in SQLiteStudio. There's no way to delete actual database file using SQLiteStudio. This is for safety reason - if you really need to delete the database file, do it using your operatins system utils (file manager, command line, ..).
Executing SQL queries
SQL Editor window
To execute any SQL queries on SQLite database you have to open SQL Editor window:
You can find it also in the 'Tools' menu:
It's also available under keyboard shortcut 'Alt+e' (by default, can be changed).
The SQL editor has a upper text edit for entering SQL queries and lower view for displaying results of the query:
If you prefer to have query edit field on one page and results on another page, you can switch it very quickly from toolbar:
And in the result you get 3 tabs in the editor, instead of 2:
Buttons on toolbar
- 1st button () executes query the you typed in the query text field below.
- 2nd button () executes
EXPLAIN
statement for the query below. - 3rd button () uses currently configured SqlFormatterPlugin to format queries typed below.
- 4th button () clears query execution history (available in the last tab of the SQL Editor window).
- 5th button () opens Export_dialog for exporting results from query typed below.
- 6th button () creates view from the
SELECT
query typed below. - 7th button ( saves contents of the query text field below into the file.
- 8th button () loads contents of selected file into the query edit field below.
- 9th position is a combo box, where you can pick current working database for the SQL Editor window. All queries are executed on database selected in this combobox.
- 10th and 11th buttons ( ) are a shortcut to configure SQL Editor results presentation mode - in separate tab, or below the query field.
The list may differ if any plugin adds its own buttons to the toolbar.
Typing SQL queries
When you type SQL query in the editor, it will highlight SQL syntax, but also if you type the correct name of any object (that is existing table, index, trigger, view, database or column name), the name gets highlighted with blue color (by default, it's configurable):
If you use incorrect SQL syntax, the problematic part will be underlined with wavy line:
To execute the query, use toolbar button , or keyboard shortcut 'F9'(the shortcut is configurable).
Error handling is done by static syntax analysis, therefore there's a chance that some errors are detected by mistake. If you think that the marked error is not really the error, you can execute query and SQLiteStudio will not analyze it. Instead it will put query directly to SQLite driver to execute it. If it was indeed correct, then it will return data, but for such cases SQLiteStudio is unable to extract metadata from query and results will not be editable. Only queries that were not marked with error marker will return full metadata and results will be editable. This limitation also affects transparent database attaching.
Even SQLiteStudio claims that the syntax is incorrect, you can still try to execute the query:
In this case, the query was invalid, obviously.
Now, let's get back to correct query (remove the 'qqq' from it) and also switch the results presentation mode, so results are displayed below query, not in separate tab:
Execute the query:
The results appeared in the view below the query and the proper execution status message appeared in the bottom status area.
You can type multiple queries, one after another, just separate them with semicolon. In this case SQLiteStudio will execute all queries types in the editor, but will present only results from the last query:
If you want to execute only one query (even more queries are typed in), select that query and then press 'Execute':
The behaviour of executing all queries typed in is a default, but you can change it, so only query which the input cursor is currently at is executed. To do so, open configuration dialog (button _on_main_toolbar), go to 'General' page and enable this option:
From now on whenever you hit 'Execute' in SQL Editor, only one query will be executed, the one under input cursor:
In this mode, after you execute current query, that entire query will be selected, so you can be sure what query exactly was executed:
Code completion
SQLiteStudio provides code assistant, so it can help you with the SQL syntax. When you hit Ctrl+Space (it's a configurable shortcut), it will show you all possible values for the current cursor position. Let say you typed '
SELECT
c
' and hit Ctrl+Space:You can see it shows only valid entries that start with the letter 'c'. Let's pick '
ccc
', then ask the assistant about next suggestions:First position (with a bullet icon) is a pseudo value, which tells you that you can put an alias name for table or column here. You typed 'ccc' before, which is a column name, so here you could type an alias name for it. We won't do that. Instead we pick '
FROM
' and add 'tab
where
' and ask the assistant again:The assistant proposes several columns which you can use in your 'where' clause, but notice, that columns from 'tab' table are listed at the begining, as you use that table in the query already. This is how the assistant tries to be smart with proposing values - when they are more likely to be used in the context, it will list them at the top.
The assistant is triggered manually by the keyboard shortcut mentioned above, but it also triggers automatically when you type '
name.
', where the name is name of existing database or table. In following example I didn't use keyboard shortcut, this just appeared after I types 'wikidb.
':There's a small problem with the assistant on Linux with KWin composition enabled, which causes the assistant to show up with a small delay (about half a second). The root cause of this problem is not yet identified. If it bothers you, disabling composition in KWin fixes this issue.
Query execution history
SQL history tab keeps the history of SQL queries you have ever executed. The number of queries kept in history is configurable in Configuration dialog and defaults 1000 entries. When that limit is exceeded, the oldest entry gets deleted.
You can browse and preview queries from the history. Double-click on the entry to automatically copy it into SQL editor, so you can re-execute it.
You can erase entire SQL queries history by clicking on 'Erase history' toolbar button and confirming your choice.
Built-in SQL functions
SQLiteStudio defines several SQL functions in databases that it connects to, so you can use them as long as you execute queries from withing SQLiteStudio.
Functions registered by SQLiteStudio are available only from SQLiteStudio. They will not be available in other applications connecting to the database, unless those applications define such functions by themself
Function | Description |
---|---|
regexp(pattern, arg) | Matches arg against pattern, where the pattern is a regular expression. This also makes the REGEXP operator available in SQL queries. Returns 1 on match, or 0 when arg was not matched. |
sqlfile(file) | Reads given file as text file containing SQL queries and executes all those queries. Returns first column of first row from results of the last query executed from the file. |
readfile(file) | Reads given file as binary file and returns bytes from it. |
writefile(file, data) | Writes given data bytes into given file. Returns number of bytes actually written. |
langs() | Returns list of scripting languages available in SQLiteStudio at the moment (this depends on what scripting language plugins are currently loaded). |
script(language, code) | Evaluates given code using scripting plugin that supports given language and returns result of the evaluation. Use langs() function to learn supported languages. |
charsets() | Returns list of charsets supported by SQLiteStudio (to be used for example in arguments for import() function) |
import_formats() | Returns list of importing formats supported by SQLiteStudio (depends on import plugins being loaded) |
import_options(format) | Returns list of currently used importing settings for certain format (the format must be one of formats returned from import_formats() ). Each setting in a separate line. Each line is a setting_name=setting_value |
import(file, format, table, charset, options) | Executes importing process using file for input, format for choosing import plugin (must be one of values returned from import_formats() ). The import is done into the table. If table does not exists, it will be created. The charset is optional and must be one of values returned from charsets() (for example 'UTF-8' ). It defaults to UTF-8. The options is optional and has to be in the same format as returned from import_options() (which is one option per line, each line is option_name=value ), although it's okay to provide only a subset of options - then the rest of settings will remain. |
html_escape(string) | Replaces HTML-specific characters in the string with their HTML escape codes and returns modified string. For example '<' will be replaced with '<'. |
url_encode(string) | Replaces URL-specific characters with their percent escape codes and returns modified string. For example '/' will be replaced with '%2F'. |
url_decode(string) | Replaces percent escape codes of the URL with their actual characters and returns modified string. For example '%2F' will be replaced with '/'. |
base64_encode(data) | Encodes given bytes with BASE64 encoding and returns BASE64 string. |
base64_decode(data) | Decodes given bytes from BASE64 encoding and returns decoded bytes. |
md4_bin(data) | Calculates MD4 hash function for given data and returns calculated value as bytes. |
md4(data) | Calculates MD4 hash function for given data and returns calculated value as hexadecimal string. |
md5_bin(data) | Calculates MD5 hash function for given data and returns calculated value as bytes. |
md5(data) | Calculates MD5 hash function for given data and returns calculated value as hexadecimal string. |
sha1(data) | Calculates SHA-1 hash function for given data and returns calculated value as bytes. |
sha224(data) | Calculates SHA-224 hash function for given data and returns calculated value as bytes. |
sha256(data) | Calculates SHA-256 hash function for given data and returns calculated value as bytes. |
sha384(data) | Calculates SHA-384 hash function for given data and returns calculated value as bytes. |
sha512(data) | Calculates SHA-512 hash function for given data and returns calculated value as bytes. |
sha3_224(data) | Calculates SHA3-224 hash function for given data and returns calculated value as bytes. |
sha3_256(data) | Calculates SHA3-256 hash function for given data and returns calculated value as bytes. |
sha3_384(data) | Calculates SHA3-384 hash function for given data and returns calculated value as bytes. |
sha3_512(data) | Calculates SHA3-512 hash function for given data and returns calculated value as bytes. |
Editing the data
In the Grid view of the data you can start editing values by:
- double-clicking on the cell (old value will remain and will be initially selected),
- selecting the cell and pressing Enter key (old value will remain and will be initially selected),
- selecting the cell and simply start typing the new value (old value will be overwritten immediately),
- right-clicking on the cell and selecting 'Edit value in editor' from the context menu (value will be edited in the separate dialog window).
Any changes you make to data are not commited immediately to the database. You have to commit them manually by clicking 'Commit' on the toolbar, or hitting 'Ctrl+Enter' keyboard shortcut (the shortcut can be changed in Configuration dialog.
If you decide to drop any changes to data you made, click on 'Rollback' on the toolbar, or hit 'Ctrl+Backspace' keyboard shortcut (it's also configurable).
You can selectively commit/rollback cells (to commit/rollback only some of current changes). To do so, select cells you want to commit/rollback and right-click on them. You will see 'Commit selected cells' and 'Rollback selected cells' positions in the context menu.
In the Form view of the data you can edit values of a single row at the time. Each cell from the row is represented here as a tabbed view/editor. By hitting 'Commit' or 'Rollback' in the Form view you commit/rollback only the current row.
The Form view operates only on rows currently visible in the Grid view, so when you reach the last row from the grid view and you want to edit next rows, you need to switch back to the Grid view, go to next data page and then go to Form view and continue your work.
Note, that before changing pages in Grid view you have to commit/rollback your current changes to the data, otherwise they will be lost.
Value editor dialog
If the column edited is of '
BLOB
' type, a separate value editor dialog will open. Editor dialog has several tabs where you can view and edit data using different modes (textual, binary, etc). The same dialog will open if you right-click on the cell and select 'Edit in value editor'.The same data editors/views are used on the Form view, so if you plan to edit all column using the value editor, you may just as good switch to the Form view.
Value editor can be configured, so it uses certain editor/view modes for the certain column datatype. To do so, use an icon on the right side of the editor view:
On the left side of the configuration you see the list of datatypes recognized by value editor, where you can select the datatype you want to configure. On top-right area you can see list of all available editor widgets (they are provided by plugins, so the list depends on what plugins you have currently loaded, but many plugins are already built into application). On bottom-right area you have a sample of how your current configuration for selected datatype look like. You can also drag&drop editor tabs to change their order. The left-most editor is a default editor for that datatype (which means that the left tab is always open first for that datatype).
If there's a datatype not specified in the configuration list and you step into that type somewhere in your database, SQLiteStudio will pick default editors (Text and Hex).
Transparent database attaching
Transparent attaching feature in SQLiteStudio is an ability of calling
ATTACH
and DETACH
automatically by SQLiteStudio whenever it's necessary. You can enter your SQL query in SQL editor using tables from several different databases, using database names as presented on databases list: Since transparent attaching calls
ATTACH
and DETACH
internally, it's affected by all limitations that apply to those statements. That is no support for attaching databases of different type. It means that you cannot mix SQLite 2 and SQLite 3 databases in the single query, or any other database type mix ups.Creating and editing tables
![Sqlite Studio For Mac Sqlite Studio For Mac](https://d2.alternativeto.net/dist/s/d83dcd33-bbf4-de11-8cae-0022190f5762_1_full.png?format=jpg&width=1200&height=1200&mode=crop&upscale=false)
TODO: remember about multi-column sorting TODO: explain difference between column constraints and table constraints
Column dialog
Column constraints
PRIMARY KEY constraints
''FOREIGN KEY constraints ''
'' NOT NULL constraints ''
'' UNIQUE constraints ''
'' COLLATE constraints ''
'' CHECK constraints ''
'' DEFAULT constraints ''
Table constraints
'' PRIMARY KEY constraints ''
'' FOREIGN KEY constraints ''
'' UNIQUE constraints ''
'' CHECK constraints ''
WITHOUT ROWID tables
Virtual tables
Creating and editing indexes
Partial indexes
Creating and editing triggers
Trigger for a View
Creating and editing views
Moving and copying objects between databases
Exporting schema and data
Importing data
Useful keyboard shortcuts
Configuration dialog
Customizing data type editors
Command line options
Here's a list of options that can be passed as arguments when running SQLiteStudio. Those options are valid only for the GUI application, for CLI there is separate set of options (click CLI to see details).
SQLiteStudio options |
---|
-h, --help |
-v, --version |
-d, --debug |
--debug-stdout |
--debug-lemon |
--debug-sql |
--debug-sql-db |
--list-plugins |
--master-config |
SQLiteStudio arguments |
---|
file |
SQLiteStudio configuration file
Download visual studio code for mac. Entire SQLiteStudio configuration is stored in a single SQLite3 database file. More details at Configuration directory location page.
SQLiteStudio updates
Automatic
Automatic updates perform:
- updates availability check,
- updates downloading,
- updates installing.
Automatic updates work only for a Portable distribution. If the application was installed from Linux's package manager, it's the responsibility of that package manager to update the application.
The updates availability check is always performed at application startup, but it can be disabled by the user (and re-enabled in configuration dialog). It can also be manually triggered by the user from menu Help / Check for updates. User is always asked for confirmation before downloading updates.
Installation of updates might require administrator privileges. If so, SQLiteStudio will ask user for password (on Linux and MacOS X), or for confirmation of privileged operation (on Windows).
HTTP proxy is not supported as for now, so if your HTTP connection requires proxy to be configured, then automatic updates will not work for you. Support for proxy configuration is planned in future versions.
Manual
Manual update is simply about downloading the fresh version from the download page and replacing old version with it.
Custom SQL functions
SQLiteStudio allows user to create additional SQL functions to be used in SQL queries. You can create for example function '
test123()
' which will return a random string for you and you will be able to type:Custom SQL functions in SQLiteStudio are very useful if your application uses some custom SQL functions for itself and you want to be able to emulate your application's environment in SQLiteStudio, so you can execute similar queries on the database.
Other use case is when you want to simplify some database maintanance tasks. Creating function which does some more complicated operations using some simple input values can be treated as a procedure by SQLite, because you can execute it with:
To create/edit/delete SQL functions, open Custom SQL Functions editor:
In the functions editor you need to define few of things:
- Function name. It needs to be unique.
- Is your function goind to be Scalar or Aggregate?
- Scalar functions are those applied to every single data row separately. Example of such function is '
length()
'. - Aggregate functions are used together with
GROUP
BY
clause and they are applied to the entire result set. Example of such function is 'min()
'.
- Scalar functions are those applied to every single data row separately. Example of such function is '
- Implementation language - a programming language that you will use to define what the function actually do.
- Input arguments - list of named input arguments. Currently they're just symbolic names used by a SQL syntax assistant to suggest what are expected input arguments. Nothing more.
- Databases - for which databases the function should be registered by SQLiteStudio.
- For Scalar function - a single implementation field is required. It's the code in chosen programing language that does the actual function's job. The return value of this code becomes the result of the function call.
- For Aggregate function there are 3 implementation fields:
- Initialization code - this code is executed once, at the begining of grouped query results. You can use it to initialize some variables to '0' values, or something like that. This field is optional.
- Per step code - this code is executed for each data row from the results. Each iteration uses the same context, which means all variables are shared across all steps.
- Final step code - it's executed after last 'per step' code. You can calculate the final result and releasy any resources you acquired. This code must return the result of the aggregate function.
Arguments passed to function are available in the code as a variables, whose names depend on certain implementation language you chose. For Tcl arguments are available in '
$argv
'. For QtScript they're in 'arguments
' array. To learn how to handle input arguments in certain language, read about the specific plugin that provides support for that language. Offical plugins are described at Scripting languages plugins page).Custom SQL functions created in SQLiteStudio exist only in context of SQLiteStudio. Functions are not persisted in database, it's just not how SQLite databases work. If you want to use some function in your own application, you have to register that function in SQLite from your application.
Custom collations
To add/edit/delete user's custom collation sequence, open Collations editor:
Collation sequence is an algorithm definition that is used by SQLite to compare two values and find out if one is less/greater/equal to another. Collations can be used in several contexts by SQLite - for example table's column can be defined with a specific collation, which will affect how is sorting done for that column, how is grouping by that column done, etc. See SQLite documentation for more details.
Collation implementation is like writting custom SQL function implementation with 2 rules:
- The collation function will always be provided with exactly 2 arguments - values to compare.
- The collation function has to return -1, 0, or 1, when first argument is less then, equal or greater than second argument.
SQLite extensions
Sqlite For Mac Download
SQLite extensions are supported only in SQLite 3. SQLite documentation for details on what are SQLite runtime loadable extensions.
To load SQLite extension into SQliteStudio database connections, open Extension Manager:
Extension manager window is similar to Collation editor window. On the left side it has list (2) of extensions already registered in the application, which are loaded for defined set (or all) of databases. At the top (1) there is a toolbar, where you can add/remove extensions and commit/rollback any changes made in the manager window. Also in that toolbar there is a help button pointing to this User Manual section.
The main part (3, 4, 5, 6) of the Extension manager window will become enabled/disabled according to your current selection in the list (2) - if there is nothing selected in the list, the main part will stay disabled. When you add/edit certain extension, you need to provide path to the library file, which delivers the extension. This is what you do in the first field (3). You can use file dialog (4) to make it easier.
The initialization function field (5) is optional and should be used if SQLite was unable to initialize an extension, due to missing initialization function. As you may have read in the SQLite documentation, the initialization function name is predicted basing on the library/extension file name, so if the file name does not match initialization function accordingly, you may need to provide the initialization function manually and that's what you can do in the field (5). Otherwise you can leave it empty.
List of databases in area (6) is just like in Collations editor and Functions editor. You can define there whether certain extension should be loaded for all databases (for SQLite version 3 only) used in the application, or should it be loaded for preselected set of databases.
SQLiteStudio will try to load (probe) the extension that you're editing (while you type the file path), so you will be notified if the file is invalid/inexisting or there is any other problem (such as initialization function not found). If anything is wrong with the extension file, you will see pulsing red dot at the left-top corner of the file entry. Once you fix file path or initialization extension function name, the red dot will disappear automatically.
Remember to commit your editions. Otherwise they will not be applied.
SQLiteStudio version 3.1.x and older supports extension loading only through load_extension() SQL function executed in SQL editor.
Populating tables
Populating tables feature is a way to insert lots of data into tables, basing on some rules, in order to have some test data to work with. It automates inserting lots of data that have predictible values, like sequence o numbers, random numbers, random text, random numbers, etc, etc.
Populating is done using rules that are defined by Populating plugins. Each plugin has its own input arguments (like minimum/maximum values, etc) and produces set of values basing on input arguments and internal algorithms.
To populate table with data, click on 'Populate table' button on Table window's toolbar. In the Populate dialog you will be able to define how many rows of data you want to produce and select which columns should be populated. Unselected columns will be populated with their default values. When selecting columns to populate, you need to pick a plugin used for populating - this determinates what data will be inserted into that column. Most plugins also have configuration available to specify some details of data production.
DDL history
When managing numerous databases and doing lots of schema changes, it's useful to have a tool to track and reproduce changed made on the schema. SQLiteStudio shows the DDL preview before executing database object creation/change statements (unless this option was disabled by user). It gets the job done, but it can be clunky to copy the DDL and paste to some it to some other text file to keep the history. It's also risky, cause one might forget to copy the DDL sometimes.
That's where the DDL history window comes in. It keeps history of any DDL changes (CREATE statements, DROP statements and any other statements related to changes of database objects), regardless of DDL preview dialog being enabled or not. It keeps information about date and time of execution and database on which the DDL was executed.
Together with SQL history from SQL Editor, DDL history window makes any changes made to any database from SQLiteStudio reproducible.
To open DDL history window, click on 'DDL history' button on toolbar:
Converting SQLite database version
If you're looking for command line options for running main SQLiteStudio application, see Command line options.
CLI is a separate, text-only console application. See Command line interface for more details.
SQLiteStudio crashed! What do I do?
Report this on bugs.sqlitestudio.pl, or - if you prefere - you can do it from SQLiteStudio. Go to Help menu and pick 'Report a bug'.
You can also ask for help on forum.sqlitestudio.pl. Sometime there is a workaround for some bugs, so you can apply them before the bug gets fixed and released in new version.
I have saved binary data into SQLite 2 database, but now it's damaged, empty or truncated!
The following applies to SQLite 2 only.
Long story short: The old SQLite 2 library is very limited in regards of data types, especially when it comes to binary data. It's better to use regular text columns and store base64-encoded data.
In more details: To be able to store binary data in SQLite 2 table, you need to define column data type as
BLOB
, or CLOB
, so SQLiteStudio knows that you will be storing binary data in that column. Without that, SQLiteStudio is unable to write and read binary data correctly from that column.Additionally, the SQLite 2 version has a bug, which makes storing binary data to be truncated to the first occurrence of the null byte (byte with value = 0), just like it is done for regular strings. There's nothing SQLiteStudio can do about it. Unless you store data with all non-null bytes, the only solution is to use regular
TEXT
based columns and store base64-encoded data.I'm using Fcitx input method, but it doesn't work in SQLiteStudio
Not sure about Windows or MacOS X, but under Linux you can use Fcitx with SQLiteStudio. Here's how to do that.
- If you are using Linux managed package:
The only thing you may need to do is to change default shortcut for SQLiteStudio code assistant (Ctrl+Space), as it is colliding with Fcitx triggering shortcut.
- If you're using Portable distribution (binary packages downloaded from SQLiteStudio's home page):
Copy
platforminputcontexts/libfcitxplatforminputcontextplugin.so
from your Qt installation into SQLiteStudio/platforminputcontexts/libfcitxplatforminputcontextplugin.so
(you will have to create the platforminputcontexts
subdirectory), restart SQLiteStudio and that's it!In other words, what you have to do is:
Just remember to change the SQLiteStudio's code assistant shortcut (Ctrl+Space), so it doesn't collide with Fcitx.
See also
Runtime Library Notes | ||
All downloadable packages on this web page that do not include the word 'static' in their file name require the appropriate version (e.g. 2005, 2008, 2010, 2012, 2013, 2015, 2017) of the Microsoft Visual C++ Runtime Library, to be successfully installed on the target machine, prior to making use of the executables contained therein. It should also be noted that the downloadable packages on this web page that include the word 'setup' (i.e. the setup packages) already include and will attempt to automatically install the required version of the Microsoft Visual C++ Runtime Library. | ||
Latest Microsoft Visual C++ Runtime Library Downloads | ||
For detailed information about the latest downloads for each Microsoft Visual C++ Runtime Library release, please refer to the following page: | ||
Latest Supported Visual C++ Downloads | ||
Support Notes - Downloadable Packages | ||
This page contains all the downloadable packages (e.g. sources, binaries, setups, etc) for the current release version of the official 'System.Data.SQLite' project. This page and the associated NuGet packages are the only official distribution points for these downloadable packages. If any of the downloadable packages are obtained elsewhere, it is very important to compare their SHA1 hashes to the corresponding hashes listed below in order to make sure the contained files are the same. | ||
Support Notes - Other Projects | ||
There are several other projects, with widely varying levels of support and compatibility, known to use the similar names. At least one of those projects is an unofficial fork of the legacy 1.0.66.0 release, modified (by a third-party) to work with Visual Studio 2010 (or higher). Only the software contained on this page is directly supported by the maintainers of this project (i.e. the SQLite Development Team) as we do not necessarily have any knowledge of the other projects that use the same (or a similar) name. That being said, if a particular question is related to the core SQLite native library itself, one of the SQLite support options is probably the best way to get an answer. | ||
Windows Embedded Compact | ||
The Precompiled Binaries for Windows CE (.NET Compact Framework) section of this page contains several binary packages for Windows Embedded Compact 2013. Further information on integrating SQLite into Windows Embedded Compact 2013 can be found at the following web site: | ||
SQLite for Windows Embedded Compact 2013 |
Release Notes | ||
The 'release notes', which contain lists of notable changes associated with each officially released version, is available on the News page. |
Package Types | ||
There are a wide variety of downloadable packages on this page. Each of them is designed to meet the requirements of a particular development and/or deployment scenario. The first step is to determine if the package is to be installed (or used) on a developer machine or a customer machine. | ||
| ||
All the 'bundle' packages contain the 'System.Data.SQLite.dll' mixed-mode assembly. These packages should only be used in cases where the assembly binary must be deployed to the Global Assembly Cache for some reason (e.g. to support some legacy application on customer machines). All the 'static' packages contain either native or mixed-mode assembly binaries linked statically to the appropriate version of the Visual C++ runtime. Typically, these packages are used in cases where customer machines may not have the necessary version of the Visual C++ runtime installed and it cannot be installed due to limited privileges. The next step is to identify the version of the .NET Framework being targeted by the application. Generally, assembly binaries linked against the .NET Framework 2.0 (or the .NET Framework 3.5) will work with the .NET Framework 4.0 (or higher); however, this is less than ideal. Furthermore, assemblies linked against the .NET Framework 4.0 (or higher) cannot be loaded by any versions of the .NET Framework prior to 4.0. | ||
Using Native Library Pre-Loading | ||
The final step is to identify the target processor architecture on both the development and customer machines. Generally, x86 binaries will work on an x64 machine running Windows (using WoW64). However, there is a problem when using managed code. If the executable that starts the process consists entirely of managed code, it will run with the native processor architecture of the machine, which will be x64 on an x64 machine. Later on, this will cause assemblies containing any native code compiled for x86 (e.g. the 'System.Data.SQLite.dll' mixed-mode assembly, the 'SQLite.Interop.dll' native interop assembly, or the 'sqlite3.dll' native library) to fail to load, typically resulting in a BadImageFormatException being thrown. If the development and customer machines may have different processor architectures, more than one binary package may be required. For this situation, using the native library pre-loading feature is highly recommended. It is available as of version 1.0.80.0 and enabled by default. In order to take advantage of this feature, the separate managed and interop assemblies must be used with XCOPY deployment (i.e. this feature is not supported by the mixed-mode assembly, nor when the assembly is deployed to the global assembly cache), resulting in an application deployment that looks something like this: | ||
| ||
The string '<bin>' above represents the directory where the application binaries are to be deployed on the target machine. With the native library pre-loading feature enabled and the application deployment shown above, the System.Data.SQLite managed-only assembly will attempt to automatically detect the processor architecture of the current process and pre-load the appropriate native library. | ||
Advanced Configuration Settings | ||
If native library pre-loading feature does not work properly in your environment, it can be disabled by setting the 'No_PreLoadSQLite' environment variable (i.e. to anything) prior to loading and/or using the System.Data.SQLite assembly. There are several more environment variables that can be used to influence the behavior of the native library pre-loading feature, documented here. Use of environment variables for configuration settings is not supported by the .NET Compact Framework builds of System.Data.SQLite, due to limitations imposed by the platform itself. Alternatively, as of version 1.0.91.0, all configuration settings can be specified via an optional XML configuration file. Using the XML configuration file when the primary System.Data.SQLite assembly ('System.Data.SQLite.dll') is being executed from the Global Assembly Cache is unsupported. For each configuration setting, the associated environment variable value, if present, will override the value specified via the XML configuration file. For the full .NET Framework, the XML configuration file must be named 'System.Data.SQLite.dll.config' and it must be present in the base directory for the application domainor the directory containing the primary System.Data.SQLite assembly as reported by its location property; otherwise, it will be ignored. For the .NET Compact Framework, the XML configuration file must be named 'System.Data.SQLite.dll.config' and it must be present in the directory containing the primary System.Data.SQLite assembly; otherwise, it will be ignored. | ||
Deployment Guidelines | ||
To summarize the above: | ||
|
List of Release Packages |
Source Code | |||
sqlite-netFx-source-1.0.111.0.zip (6.54 MiB) | This ZIP archive contains all current source code for System.Data.SQLite 1.0.111.0 (3.28.0) combined into a single archive file. (sha1: 22de5d50a5a29ad794c77e702d536cd9f36dc7c6) | ||
sqlite-netFx-full-source-1.0.111.0.zip (11.41 MiB) | This ZIP archive contains all current source code for System.Data.SQLite 1.0.111.0 (3.28.0) and the extra files needed to run the unit test suite, combined into a single archive file. (sha1: 0aba06b3ce3d46b74700b725d578e20567dc631e) | ||
Setups for 32-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-setup-bundle-x86-2005-1.0.111.0.exe (5.63 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 is included. The .NET Framework 2.0 SP2 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2005. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. (sha1: bb429bc3ec37e4246e2fcb906dcb657cc15637b5) | ||
sqlite-netFx20-setup-x86-2005-1.0.111.0.exe (5.62 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 is included. The .NET Framework 2.0 SP2 is required. (sha1: c1f4124457d85b62264d299343681a93b2c3eedc) | ||
Setups for 64-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-setup-bundle-x64-2005-1.0.111.0.exe (6.29 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 is included. The .NET Framework 2.0 SP2 is required. (sha1: 3ba30aa629b30dea04f9b2e1fd189d6aeafaebd9) | ||
sqlite-netFx20-setup-x64-2005-1.0.111.0.exe (6.27 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 is included. The .NET Framework 2.0 SP2 is required. (sha1: 6c12b187488638f06abf3bf317278ee1ee8605e8) | ||
Setups for 32-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-setup-bundle-x86-2008-1.0.111.0.exe (7.67 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 is included. The .NET Framework 3.5 SP1 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2008. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. (sha1: 3ae1e47f787c0551e598bfecca365af3b6a63fda) | ||
sqlite-netFx35-setup-x86-2008-1.0.111.0.exe (7.65 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 is included. The .NET Framework 3.5 SP1 is required. (sha1: f0bd89a3456a9295e0bc691615cabfbe53a4f41a) | ||
Setups for 64-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-setup-bundle-x64-2008-1.0.111.0.exe (8.44 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 is included. The .NET Framework 3.5 SP1 is required. (sha1: 2affb5580e62c34aca7b291be0aeb23cf1d644f1) | ||
sqlite-netFx35-setup-x64-2008-1.0.111.0.exe (8.43 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 is included. The .NET Framework 3.5 SP1 is required. (sha1: 391b45105b7684ea1949c47df091b4d1fdae4210) | ||
Setups for 32-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-setup-bundle-x86-2010-1.0.111.0.exe (13.25 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 is included. The .NET Framework 4.0 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2010. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. (sha1: 0c2be632cc2da1ffbc0daf91af9d0609da164b4b) | ||
sqlite-netFx40-setup-x86-2010-1.0.111.0.exe (13.24 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 is included. The .NET Framework 4.0 is required. (sha1: 04d7431e11e06976859b226525a1643f88fec56e) | ||
Setups for 64-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-setup-bundle-x64-2010-1.0.111.0.exe (14.53 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 is included. The .NET Framework 4.0 is required. (sha1: 3ff2e3aba25b2138191ec5c30026becb3eba2cd3) | ||
sqlite-netFx40-setup-x64-2010-1.0.111.0.exe (14.52 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 is included. The .NET Framework 4.0 is required. (sha1: 8c2176dc9a2ba9f94f91c38bbb11f907a25b6431) | ||
Setups for 32-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-setup-bundle-x86-2012-1.0.111.0.exe (10.67 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 is included. The .NET Framework 4.5 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2012. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. Using Entity Framework 6 design-time support may require installing the Visual Studio 2012 'flavor' of the Entity Framework 6 Tools for Visual Studio 2012 & 2013. (sha1: 328471b6ba1a59d98cbd91a7d081c0a168ce0163) | ||
sqlite-netFx45-setup-x86-2012-1.0.111.0.exe (10.71 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 is included. The .NET Framework 4.5 is required. (sha1: deb8de39514f83876c75c93b8cc8e4330ca64e47) | ||
Setups for 64-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-setup-bundle-x64-2012-1.0.111.0.exe (11.34 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 is included. The .NET Framework 4.5 is required. (sha1: b4bf894a8ee213f130cdb39135f5c8014010b2a2) | ||
sqlite-netFx45-setup-x64-2012-1.0.111.0.exe (11.41 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 is included. The .NET Framework 4.5 is required. (sha1: 0b69a5fa5ded5b794f22f100e59edbb8e011a482) | ||
Setups for 32-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-setup-bundle-x86-2013-1.0.111.0.exe (10.63 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 is included. The .NET Framework 4.5.1 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2013. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. Using Entity Framework 6 design-time support may require installing the Visual Studio 2013 'flavor' of the Entity Framework 6 Tools for Visual Studio 2012 & 2013. (sha1: bba4dd9dc227846c2b7f4e77a4bb005428a37ae6) | ||
sqlite-netFx451-setup-x86-2013-1.0.111.0.exe (10.66 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 is included. The .NET Framework 4.5.1 is required. (sha1: fe668016a2dbd017db9996a266d450efb668d1f7) | ||
Setups for 64-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-setup-bundle-x64-2013-1.0.111.0.exe (11.33 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 is included. The .NET Framework 4.5.1 is required. (sha1: f05075f344e99777f1ea5b8428dd500ef02eef18) | ||
sqlite-netFx451-setup-x64-2013-1.0.111.0.exe (11.40 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 is included. The .NET Framework 4.5.1 is required. (sha1: 3ffd31a5459533aae23eda86648449c0835aa9c1) | ||
Setups for 32-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-setup-bundle-x86-2015-1.0.111.0.exe (17.21 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 is included. The .NET Framework 4.6 is required. This is the only setup package that is capable of installing the design-time components for Visual Studio 2015. However, if you do not require the design-time components, please consider downloading the associated 'Precompiled Binaries' instead. (sha1: f9fb9335442b32dea913138a10ed78c9cd7d483a) | ||
sqlite-netFx46-setup-x86-2015-1.0.111.0.exe (17.38 MiB) | This setup package will install all the necessary runtime components and dependencies for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 is included. The .NET Framework 4.6 is required. (sha1: 4c7b1e0931366140d6ebc0cf4b7cc588f0a3d0be) | ||
Setups for 64-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-setup-bundle-x64-2015-1.0.111.0.exe (18.07 MiB) | This setup package features the mixed-mode assembly and will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 is included. The .NET Framework 4.6 is required. (sha1: 1efb22e094a099bcc9f2e06375a8c63f712b1151) | ||
sqlite-netFx46-setup-x64-2015-1.0.111.0.exe (18.32 MiB) | This setup package will install all the necessary runtime components and dependencies for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 is included. The .NET Framework 4.6 is required. (sha1: dc28fc15ff55b1fce8a1a7616e1299081034adde) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-binary-bundle-Win32-2005-1.0.111.0.zip (1.99 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 and the .NET Framework 2.0 SP2 are required. (sha1: e5eaec372410a4d844f78498b4dda6d52f351c0b) | ||
sqlite-netFx20-binary-Win32-2005-1.0.111.0.zip (1.99 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 and the .NET Framework 2.0 SP2 are required. (sha1: 385284fca17e2c9648eeededc9f1d99702ab77a9) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-binary-bundle-x64-2005-1.0.111.0.zip (2.29 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 and the .NET Framework 2.0 SP2 are required. (sha1: d0620ad11353a5eddb18c95252a3b2fb22df2abd) | ||
sqlite-netFx20-binary-x64-2005-1.0.111.0.zip (2.28 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 and the .NET Framework 2.0 SP2 are required. (sha1: 1d23d399bca266addc40dc8b0aacb50aad80a25c) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-binary-bundle-Win32-2008-1.0.111.0.zip (2.44 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 and the .NET Framework 3.5 SP1 are required. (sha1: fccde012d7474278ad14abf70295f7ce63eef721) | ||
sqlite-netFx35-binary-Win32-2008-1.0.111.0.zip (2.43 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 and the .NET Framework 3.5 SP1 are required. (sha1: e988805176edfaec93ac7fff6c43226c3ce488d9) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-binary-bundle-x64-2008-1.0.111.0.zip (2.56 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 and the .NET Framework 3.5 SP1 are required. (sha1: 9f3ab689ace72e71a20435e7a01147e79c8dd6d4) | ||
sqlite-netFx35-binary-x64-2008-1.0.111.0.zip (2.56 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 and the .NET Framework 3.5 SP1 are required. (sha1: e026093abe90badb7638e284982550088bef72bd) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-binary-bundle-Win32-2010-1.0.111.0.zip (2.68 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 and the .NET Framework 4.0 are required. (sha1: 084387bc0ed65b6165ce2140f74c2e373d2d58eb) | ||
sqlite-netFx40-binary-Win32-2010-1.0.111.0.zip (2.68 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 and the .NET Framework 4.0 are required. (sha1: 44882c12047522904f862b382f8cddc995e17a19) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-binary-bundle-x64-2010-1.0.111.0.zip (2.74 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 and the .NET Framework 4.0 are required. (sha1: 628fa8c6803cc2e50517e10efea79b63f5812277) | ||
sqlite-netFx40-binary-x64-2010-1.0.111.0.zip (2.73 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 and the .NET Framework 4.0 are required. (sha1: 8af4e6c396afe94b5efe79af8b62cda17bd57260) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-binary-bundle-Win32-2012-1.0.111.0.zip (2.58 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 and the .NET Framework 4.5 are required. (sha1: 9fd46dd6a9a485d8e516c242127dbdd3535805b9) | ||
sqlite-netFx45-binary-Win32-2012-1.0.111.0.zip (2.63 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 and the .NET Framework 4.5 are required. (sha1: 45b5a428fb481574f402ba61408d81b07a57759a) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-binary-bundle-x64-2012-1.0.111.0.zip (2.63 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 and the .NET Framework 4.5 are required. (sha1: 33b8c17e99a9970eebcaa913787ea4675bf6c1f6) | ||
sqlite-netFx45-binary-x64-2012-1.0.111.0.zip (2.73 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 and the .NET Framework 4.5 are required. (sha1: df65689545111bb1e0d8afa91cb170b9b61f6800) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-binary-bundle-Win32-2013-1.0.111.0.zip (2.58 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 and the .NET Framework 4.5.1 are required. (sha1: 081efd1dcd7521644a2e7bef670c3783f1c3a0e9) | ||
sqlite-netFx451-binary-Win32-2013-1.0.111.0.zip (2.64 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 and the .NET Framework 4.5.1 are required. (sha1: a082f17888092e0efe6c48747b32009c6def4ff5) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-binary-bundle-x64-2013-1.0.111.0.zip (2.63 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 and the .NET Framework 4.5.1 are required. (sha1: 8c9d830dd36504e03a26763cb93a83df7cdf316a) | ||
sqlite-netFx451-binary-x64-2013-1.0.111.0.zip (2.74 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 and the .NET Framework 4.5.1 are required. (sha1: ea360473b6e2f4a1e3fc2b4d4e1079d62336c1b2) | ||
Precompiled Binaries for 32-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-binary-bundle-Win32-2015-1.0.111.0.zip (3.22 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 and the .NET Framework 4.6 are required. (sha1: f1b16b019ef44972eb0e9e42be8a8d4ef1cf31d7) | ||
sqlite-netFx46-binary-Win32-2015-1.0.111.0.zip (3.43 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 and the .NET Framework 4.6 are required. (sha1: e94ff79be79cfbf4e3b3ab0545f15987c2cceda1) | ||
Precompiled Binaries for 64-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-binary-bundle-x64-2015-1.0.111.0.zip (3.28 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 and the .NET Framework 4.6 are required. (sha1: 588847bc7a4c18d2e170137e13d10dd59ffaa94b) | ||
sqlite-netFx46-binary-x64-2015-1.0.111.0.zip (3.59 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 and the .NET Framework 4.6 are required. (sha1: 885815d93281c6343be006a3c39ee73bb42f3f36) | ||
Precompiled Binaries for Mono on POSIX (.NET Framework 4.5.1) | |||
sqlite-netFx451-binary-Mono-2013-1.0.111.0.zip (1.29 MiB) | This binary package contains all the managed binaries for the Mono version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Mono runtime (4.2.3.4 or higher) is required. (sha1: f4a51a01610569a022fb66e0deb07d0cec34c2b3) | ||
Precompiled Binaries for the .NET Standard 2.0 (.NET Core 2.0) | |||
sqlite-netStandard20-binary-1.0.111.0.zip (0.29 MiB) | This binary package contains all the managed binaries for the .NET Standard 2.0 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The .NET Core runtime (2.0 or higher) is required. (sha1: 38ded88e647973333ebb57182d1316d4b04fd687) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-static-binary-bundle-Win32-2005-1.0.111.0.zip (2.19 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 is statically linked. The .NET Framework 2.0 SP2 is required. (sha1: b19396e94c8d240de3815b28df3ca4e385b3f752) | ||
sqlite-netFx20-static-binary-Win32-2005-1.0.111.0.zip (2.18 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x86 is statically linked. The .NET Framework 2.0 SP2 is required. (sha1: eb3f87ec526a7ad0331b0942db3220378e0e904b) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 2.0 SP2) | |||
sqlite-netFx20-static-binary-bundle-x64-2005-1.0.111.0.zip (2.43 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 is statically linked. The .NET Framework 2.0 SP2 is required. (sha1: bd309ba7d5f32d60461ef9628f3bc74e1d868616) | ||
sqlite-netFx20-static-binary-x64-2005-1.0.111.0.zip (2.42 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2005 SP1 runtime for x64 is statically linked. The .NET Framework 2.0 SP2 is required. (sha1: b90f0aca94aafb4a77dbc1d92951be8253dfb03b) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-static-binary-bundle-Win32-2008-1.0.111.0.zip (2.64 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 is statically linked. The .NET Framework 3.5 SP1 is required. (sha1: 15319baec142331293500d818735e79de6f3437c) | ||
sqlite-netFx35-static-binary-Win32-2008-1.0.111.0.zip (2.63 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x86 is statically linked. The .NET Framework 3.5 SP1 is required. (sha1: db5bf782d79ddc66bdce2969a0a94a3b687f7cbb) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 3.5 SP1) | |||
sqlite-netFx35-static-binary-bundle-x64-2008-1.0.111.0.zip (2.72 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 is statically linked. The .NET Framework 3.5 SP1 is required. (sha1: 33dbe33b1db9155e63278f198f735cb8bebc9a7f) | ||
sqlite-netFx35-static-binary-x64-2008-1.0.111.0.zip (2.71 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2008 SP1 runtime for x64 is statically linked. The .NET Framework 3.5 SP1 is required. (sha1: 34febbe50cb48123703ee1b9dd505b6e703ed640) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-static-binary-bundle-Win32-2010-1.0.111.0.zip (2.88 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 is statically linked. The .NET Framework 4.0 is required. (sha1: d4571803352b477db1a64d702b61c31fd4f9fb80) | ||
sqlite-netFx40-static-binary-Win32-2010-1.0.111.0.zip (2.87 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x86 is statically linked. The .NET Framework 4.0 is required. (sha1: 738ef0202d93316e03a11f9002e0b7b7e9a4d3fa) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.0) | |||
sqlite-netFx40-static-binary-bundle-x64-2010-1.0.111.0.zip (2.91 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 is statically linked. The .NET Framework 4.0 is required. (sha1: 4a06b055222298c60f49f6f40187b0372e3c0c4e) | ||
sqlite-netFx40-static-binary-x64-2010-1.0.111.0.zip (2.91 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2010 SP1 runtime for x64 is statically linked. The .NET Framework 4.0 is required. (sha1: 02e63151ca7336ef9e55bcd5646c90d6975ab9f8) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-static-binary-bundle-Win32-2012-1.0.111.0.zip (2.90 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 is statically linked. The .NET Framework 4.5 is required. (sha1: f2de38bf13ee70b90fd8bbe572ffd21258b2f865) | ||
sqlite-netFx45-static-binary-Win32-2012-1.0.111.0.zip (2.96 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x86 is statically linked. The .NET Framework 4.5 is required. (sha1: 2c9833695259dacf5ce3167d9963dfdf3361dfd2) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.5) | |||
sqlite-netFx45-static-binary-bundle-x64-2012-1.0.111.0.zip (2.89 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 is statically linked. The .NET Framework 4.5 is required. (sha1: 26f6fdfb8956a3ad9fc12ca5f9806b5aa8a1a429) | ||
sqlite-netFx45-static-binary-x64-2012-1.0.111.0.zip (2.99 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2012 Update 4 runtime for x64 is statically linked. The .NET Framework 4.5 is required. (sha1: 8558b7c60a6f5c6b2577c0f66c85d425307376fe) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-static-binary-bundle-Win32-2013-1.0.111.0.zip (2.93 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 is statically linked. The .NET Framework 4.5.1 is required. (sha1: ed7ed2c421a13a260afaec1d52bce7c69bade599) | ||
sqlite-netFx451-static-binary-Win32-2013-1.0.111.0.zip (2.98 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x86 is statically linked. The .NET Framework 4.5.1 is required. (sha1: e542337e0ef595c02bc6707e4d7aa987c5e72ca4) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.5.1) | |||
sqlite-netFx451-static-binary-bundle-x64-2013-1.0.111.0.zip (2.93 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 is statically linked. The .NET Framework 4.5.1 is required. (sha1: 1b9ef7a79246ccfb087a083aec23ff39633ccb0e) | ||
sqlite-netFx451-static-binary-x64-2013-1.0.111.0.zip (3.03 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2013 Update 2 runtime for x64 is statically linked. The .NET Framework 4.5.1 is required. (sha1: 32d7e3783378a4c37477754e641def164d93a397) | ||
Precompiled Statically-Linked Binaries for 32-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-static-binary-bundle-Win32-2015-1.0.111.0.zip (3.73 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 is statically linked. The .NET Framework 4.6 is required. (sha1: 1d9ac17de85d5d69818753ce7747fedc46c7c187) | ||
sqlite-netFx46-static-binary-Win32-2015-1.0.111.0.zip (3.95 MiB) | This binary package contains all the binaries for the x86 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x86 is statically linked. The .NET Framework 4.6 is required. (sha1: 3480b0624eab0202992a4992fde27a97146c93d4) | ||
Precompiled Statically-Linked Binaries for 64-bit Windows (.NET Framework 4.6) | |||
sqlite-netFx46-static-binary-bundle-x64-2015-1.0.111.0.zip (3.76 MiB) | This binary package features the mixed-mode assembly and contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 is statically linked. The .NET Framework 4.6 is required. (sha1: 4c781f491f3567815e099b12c01bf2fe66e81dc3) | ||
sqlite-netFx46-static-binary-x64-2015-1.0.111.0.zip (4.07 MiB) | This binary package contains all the binaries for the x64 version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The Visual C++ 2015 Update 3 runtime for x64 is statically linked. The .NET Framework 4.6 is required. (sha1: d2a5727ebd37eb6b8f6045207814b4440b72623b) | ||
Precompiled Binaries for Windows CE (.NET Compact Framework) | |||
sqlite-netFx35-binary-PocketPC-ARM-2008-1.0.111.0.zip (1.53 MiB) | This binary package contains all the binaries for the PocketPC version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The included native binaries should work on all supported ARM versions of Windows CE prior to Windows Embedded Compact 2013. The .NET Compact Framework 3.5 is required. (sha1: c3e723cb2b4d1bd317c47806b1dddeb0b8cadde8) | ||
sqlite-netFx39-binary-WinCE-ARM-2012-1.0.111.0.zip (1.70 MiB) | This binary package contains all the binaries for the Windows Embedded Compact 2013 (ARM) version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The .NET Compact Framework 3.9 is required. (sha1: fef8c29f6dc7575c18d97b667a809b9ed11722ac) | ||
sqlite-netFx39-binary-WinCE-x86-2012-1.0.111.0.zip (1.75 MiB) | This binary package contains all the binaries for the Windows Embedded Compact 2013 (x86) version of the System.Data.SQLite 1.0.111.0 (3.28.0) package. The .NET Compact Framework 3.9 is required. (sha1: 214e2560505d3bab494a4de55d258030aa525fa7) | ||
Official NuGet Packages | |||
Generally, the official NuGet packages should be obtained from the NuGet Gallery; however, they are also included here as 'local downloads' for reference. They should be absolutely identical to those listed on the NuGet Gallery with the same name and version. The SHA1 hashes listed below may be used for comparison purposes. | |||
System.Data.SQLite.1.0.111.0.nupkg (0.00 MiB) | This NuGet package includes all the binaries for both the x86 and x64 versions of System.Data.SQLite 1.0.111.0 (3.28.0). The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 -OR- .NET Core 2.0 is required. For the included Windows native binaries, the version of the Visual C++ runtime corresponding to the .NET Framework used by the associated managed assembly is statically linked. For the included Linux native binaries, Ubuntu 16.04 LTS compatible runtime libraries are required. For the included macOS native binaries, macOS Sierra compatible runtime libraries are required. This package depends on the 'EntityFramework' package, version 6.0 or higher (indirectly via the 'System.Data.SQLite.EF6' package). As of version 1.0.92.0, this package will not directly contain any of the required binaries. Instead, this package will depend on the 'System.Data.SQLite.Core', 'System.Data.SQLite.Linq', and 'System.Data.SQLite.EF6' packages. (sha1: 962f5155783590788e76fbb4889cfaa7649d666c) | ||
System.Data.SQLite.Core.1.0.111.0.nupkg (11.99 MiB) | This NuGet package contains all the binaries for both the x86 and x64 versions of System.Data.SQLite 1.0.111.0 (3.28.0), except those needed to support LINQ and Entity Framework 6. The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required -OR- .NET Core 2.0 is required. For the included Windows native binaries, the version of the Visual C++ runtime corresponding to the .NET Framework used by the associated managed assembly is statically linked. For the included Linux native binaries, Ubuntu 16.04 LTS compatible runtime libraries are required. For the included macOS native binaries, macOS Sierra compatible runtime libraries are required. This package does not depend on any other package. (sha1: 6c3c9cc5b9824e3ffcfb059e0655951ae6f556bf) | ||
System.Data.SQLite.Core.MSIL.1.0.111.0.nupkg (1.45 MiB) | This NuGet package contains the managed binaries for System.Data.SQLite 1.0.111.0. The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. This package does not depend on any other package. This NuGet package does not include any code from the native SQLite core library and will not work properly without the native assembly 'SQLite.Interop.dll' compiled for the processor architecture of the host process being present in a directory in the native library search path. (sha1: ff3cf261f2d9a43ae11e640bc3ff0c3567233a94) | ||
System.Data.SQLite.EF6.1.0.111.0.nupkg (0.18 MiB) | This NuGet package contains just the binaries to support Entity Framework 6 using System.Data.SQLite 1.0.111.0 (3.28.0). The .NET Framework 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. This package depends on the 'EntityFramework' package, version 6.0 or higher. (sha1: 94ead547ee10be04e6fd989853af772334e54246) | ||
System.Data.SQLite.Linq.1.0.111.0.nupkg (0.22 MiB) | This NuGet package contains just the binaries to support LINQ using System.Data.SQLite 1.0.111.0 (3.28.0). The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. This package does not depend on any other package. (sha1: f8a16294d8f23a528b98ddbe8418c2a6f7d5d0e0) | ||
System.Data.SQLite.MSIL.1.0.111.0.nupkg (0.00 MiB) | This NuGet package contains the managed binaries for System.Data.SQLite 1.0.111.0. The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. This is a legacy package; if possible, please use either the 'System.Data.SQLite' or 'System.Data.SQLite.Core' package instead. This NuGet package does not include any code from the native SQLite core library and will not work properly without the native assembly 'SQLite.Interop.dll' compiled for the processor architecture of the host process being present in a directory in the native library search path. As of version 1.0.95.0, this package will not directly contain any of the required binaries. Instead, this package will depend on the 'System.Data.SQLite.Core.MSIL', 'System.Data.SQLite.Linq', and 'System.Data.SQLite.EF6' packages. (sha1: d217e0e67fddae77f77cbfdc2ce55f615cd49137) | ||
System.Data.SQLite.x86.1.0.111.0.nupkg (4.35 MiB) | This NuGet package contains all the binaries for the x86 version of System.Data.SQLite 1.0.111.0 (3.28.0). The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. For the included native binaries, the version of the Visual C++ runtime corresponding to the .NET Framework used by the associated managed assembly is statically linked. This is a legacy package; if possible, please use either the 'System.Data.SQLite' or 'System.Data.SQLite.Core' package instead. (sha1: d43e723002f037865e883f8585704df2031d00d5) | ||
System.Data.SQLite.x64.1.0.111.0.nupkg (4.93 MiB) | This NuGet package contains all the binaries for the x64 version of System.Data.SQLite 1.0.111.0 (3.28.0). The .NET Framework 3.5 SP1, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, or 4.7.2 is required. For the included native binaries, the version of the Visual C++ runtime corresponding to the .NET Framework used by the associated managed assembly is statically linked. This is a legacy package; if possible, please use either the 'System.Data.SQLite' or 'System.Data.SQLite.Core' package instead. (sha1: 8af100205174305e33084c241fe4aa566ab860a8) | ||
Legacy Versions | |||
SQLite-1.0.66.0-setup.exe | Legacy versions may still be found at SourceForge, though there have been no updates there since April of 2010. |
Build Product Names
Beginning with System.Data.SQLite version 1.0.101.0 (3.12.2), the following templates will be used for the names of the build products:
- sqlite-netFx-source-version.zip
- sqlite-netFx-source-version.tar.gz
- sqlite-netFx-full-source-version.zip
- sqlite-netFx-full-source-version.tar.gz
- sqlite-framework-setup-cpu-year-version.exe
- sqlite-framework-setup-bundle-cpu-year-version.exe
- sqlite-framework-binary-platform-year-version.zip
- sqlite-framework-binary-bundle-platform-year-version.zip
- sqlite-framework-static-binary-platform-year-version.zip
- sqlite-framework-static-binary-bundle-platform-year-version.zip
- sqlite-netFx-source-date.zip
- sqlite-netFx-full-source-date.zip
- System.Data.SQLite.version.nupkg
- System.Data.SQLite.variant.version.nupkg
- System.Data.SQLite.variant.releaseType.version.nupkg
Templates (1), (2), (3), and (4) are used for source-code packages. Templates (1) and (3) are used for generic source-code packages and templates (2) and (4) are used for source-code packages that are generally only useful on unix-like platforms. Templates (3) and (4) are used for source-code packages that include the extra files needed to run the unit test suite.
Templates (5) and (6) are used for the setup packages. Template (6) is used for the setup package containing the mixed-mode assembly.
Templates (7) and (8) are used for the precompiled binary packages. Template (8) is used for the precompiled binary package containing the mixed-mode assembly. Templates (9) and (10) are used for the precompiled binary packages statically linked to the Visual C++ runtime. Template (10) is used for the precompiled binary package containing the mixed-mode assembly statically linked to the Visual C++ runtime.
Templates (11) and (12) are used for unofficial pre-release 'snapshots' of source code.
Templates (13), (14), and (15) are used for the official NuGet packages.
The framework in templates (5), (6), (7), (8), (9), and (10) will be one of netFx20, netFx35, netFx40, netFx45, netFx451, netFx452, netFx46, netFx461, netFx462, netFx47, netFx471, netFx472.
The cpu in templates (5) and (6) will be one of x86, x64, arm, ia64.
The platform in templates (7), (8), (9), and (10) will be one of Win32, x64, PocketPC, PocketPC-ARM, PocketPC-x86, WinCE-ARM, WinCE-x86, Mono.
The year in templates (5), (6), (7), (8), (9), and (10) will be one of 2005, 2008, 2010, 2012, 2013, 2015, 2017, 20XX, NetStandard20.
The version in templates (1), (2), (3), (4), (5), (6), (7), (8), (9), (10), (13), (14), and (15) is the dot-delimited version number of the primary System.Data.SQLite assembly.
The date in template (11) and (12) is of the form: YYYYMMDDHHMM
The variant in template (14) and (15) will be MSIL, x86, or x64. Alternatively, it may be absent, which represents the default variant.
The releaseType in template (15) will be Beta or Test. Alternatively, it may be absent, which represents the default release type.
- The 'Beta' release type is used to indicate that the package was intended to be used for beta testing.
- The 'Test' release type is used to indicate that the package was intended to be used for release candidate testing.
Canonical Source Code
Sqlite Visual Studio For Mac
The canonical System.Data.SQLite source code is maintained in a Fossil repository that is available for anonymous read-only access. Anyone can view the repository contents and download historical versions of individual files or ZIP archives of historical check-ins.
R Studio For Mac
The complete source tree for any check-in may always be downloaded using the 'Tarball' or 'ZIP archive' links available from each check-in detail page.