System.Data.SQLite
Check-in [7ec6a118ce]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:1.0.66.0
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | sourceforge | release
Files: files | file ages | folders
SHA1: 7ec6a118ce040dcf0a25d39b1a2f46d79b4ded3a
User & Date: rmsimpson 2010-08-05 02:03:34
Original Comment: 1.0.66.0
Context
2010-08-11
16:11
Fixing VS2005 support and adding VS2010 support check-in: 835bf14e60 user: rmsimpson tags: sourceforge
2010-08-05
02:03
1.0.66.0 check-in: 7ec6a118ce user: rmsimpson tags: sourceforge, release
2009-07-10
04:43
1.0.64.0 check-in: de1a94066c user: rmsimpson tags: sourceforge
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Doc/Extra/dbfactorysupport.html.

    93     93   <configuration>
    94     94     <system.data>
    95     95       <DbProviderFactories>
    96     96         <remove invariant="System.Data.SQLite"/>
    97     97         <add name="SQLite Data Provider" invariant="System.Data.SQLite" 
    98     98              description=".Net Framework Data Provider for SQLite"
    99     99              type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite,
   100         -                 Version=1.0.64.0, Culture=neutral,
          100  +                 Version=1.0.66.0, Culture=neutral,
   101    101                    PublicKeyToken=db937bc2d44ff139"/>
   102    102       </DbProviderFactories>
   103    103     </system.data>
   104    104   </configuration>
   105    105   </pre>
   106    106         </div>
   107    107         <p>

Changes to Doc/Extra/version.html.

    51     51             </td>
    52     52           </tr>
    53     53         </table>
    54     54       </div>
    55     55       <div id="mainSection">
    56     56       <div id="mainBody">
    57     57       <h1 class="heading">Version History</h1>
           58  +    <p><b>1.0.66.0 - April 18, 2010</b></p>
           59  +    <ul>
           60  +      <li>Code merge with SQLite 3.6.23.1</li>
           61  +      <li>Fixed a bug in the installer that accidentally modified the machine.config on .NET versions prior to 2.0, invaliding the config file.</li>
           62  +      <li>Fixed INTERSECT and EXCEPT union query generation in EF</li>
           63  +      <li>Fixed an out of memory error in the trigger designer in cases where a WHEN clause is used in the trigger</li>
           64  +    </ul>
           65  +    <p><b>1.0.65.0 - July 26, 2009</b></p>
           66  +    <ul>
           67  +      <li>Fixed a bug in the encryption module to prevent a double free() when rekeying a database.</li>
           68  +      <li>Fixed a bug in the encryption module when ATTACHing an encrypted database.</li>
           69  +      <li>Incorporated the WinCE locking fix from ticket
           70  +        <a href="http://www.sqlite.org/cvstrac/tktview?tn=3991">#3991</a></li>
           71  +      <li>Added &quot;bigint&quot; to the dropdown in the table designer, plus other minor table 
           72  +        designer bugfixes.</li>
           73  +    </ul>
    58     74       <p><b>1.0.64.0 - July 9, 2009</b></p>
    59     75       <ul>
    60     76         <li>Fixed the missing resources problem from the 63 release.</li>
    61     77         <li>Added preliminary support for the Visual Studio 2010 beta.</li>
    62     78         <li>Fixed a bug in SQLiteCommand that threw a null reference exception when 
    63     79           setting the Transaction object to null.</li>
    64     80         <li>If SQLiteConnection.EnlistTransaction is called multiple times for the same 

Changes to Doc/SQLite.NET.chm.

cannot compute difference between binary files

Changes to SQLite.Designer/AssemblyInfo.cs.

     1      1   using System;
     2      2   using System.Reflection;
     3      3   using System.Runtime.CompilerServices;
     4      4   using System.Runtime.InteropServices;
     5      5   using System.Runtime.ConstrainedExecution;
            6  +using System.Resources;
     6      7   
     7      8   // General Information about an assembly is controlled through the following 
     8      9   // set of attributes. Change these attribute values to modify the information
     9     10   // associated with an assembly.
    10     11   [assembly: AssemblyTitle("SQLite.Designer")]
    11     12   [assembly: AssemblyDescription("ADO.NET 2.0 Data Designer for SQLite")]
    12     13   [assembly: AssemblyConfiguration("")]
................................................................................
    18     19   
    19     20   // Setting ComVisible to false makes the types in this assembly not visible 
    20     21   // to COM componenets.  If you need to access a type in this assembly from 
    21     22   // COM, set the ComVisible attribute to true on that type.
    22     23   [assembly: ComVisible(false)]
    23     24   [assembly: CLSCompliant(true)]
    24     25   [assembly: ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
           26  +[assembly: NeutralResourcesLanguage("en")]
    25     27   
    26     28   // Version information for an assembly consists of the following four values:
    27     29   //
    28     30   //      Major Version
    29     31   //      Minor Version 
    30     32   //      Build Number
    31     33   //      Revision
    32     34   //
    33     35   // You can specify all the values or you can default the Revision and Build Numbers 
    34     36   // by using the '*' as shown below:
    35         -[assembly: AssemblyVersion("1.0.36.0")]
    36         -[assembly: AssemblyFileVersion("1.0.36.0")]
           37  +[assembly: AssemblyVersion("1.0.37.0")]
           38  +[assembly: AssemblyFileVersion("1.0.37.0")]
    37     39   [assembly: AssemblyDelaySignAttribute(false)]
    38     40   [assembly: AssemblyKeyFileAttribute("..\\System.Data.SQLite\\System.Data.SQLite.snk")]
    39     41   [assembly: AssemblyKeyNameAttribute("")]

Changes to SQLite.Designer/ChangePasswordDialog.cs.

    18     18     using System.Windows.Forms.Design;
    19     19     using Microsoft.VisualStudio.Shell.Interop;
    20     20     using Microsoft.VisualStudio;
    21     21     using System.Data.Common;
    22     22   
    23     23     public partial class ChangePasswordDialog : Form
    24     24     {
    25         -    internal string Password = null;
           25  +    internal string Password;
    26     26   
    27     27       private SQLiteConnectionProperties _props;
    28     28   
    29     29       private string GetCurrentPassword()
    30     30       {
    31     31         try
    32     32         {

Changes to SQLite.Designer/ChangeScriptDialog.cs.

    10     10     using System;
    11     11     using System.Collections.Generic;
    12     12     using System.ComponentModel;
    13     13     using System.Data;
    14     14     using System.Drawing;
    15     15     using System.Text;
    16     16     using System.Windows.Forms;
           17  +  using System.Globalization;
    17     18     using SQLite.Designer.Design;
    18     19   
    19     20     public partial class ChangeScriptDialog : Form
    20     21     {
    21     22       private string _tableName;
    22     23       private static bool _defaultSave;
    23     24   
................................................................................
    55     56       private void yesButton_Click(object sender, EventArgs e)
    56     57       {
    57     58         using (SaveFileDialog save = new SaveFileDialog())
    58     59         {
    59     60           save.DefaultExt = "sql";
    60     61           save.OverwritePrompt = true;
    61     62           save.Filter = "SQL Script Files (*.sql)|*.sql|All Files (*.*)|*.*";
    62         -        save.FileName = String.Format("{0}.sql", _tableName);
           63  +        save.FileName = String.Format(CultureInfo.InvariantCulture, "{0}.sql", _tableName);
    63     64           save.Title = "Save SQLite Change Script";
    64     65   
    65     66           DialogResult = save.ShowDialog(this);
    66     67   
    67     68           if (DialogResult == DialogResult.OK)
    68     69           {
    69     70             _defaultSave = _saveOrig.Checked;

Changes to SQLite.Designer/SQLite.Designer.csproj.

     1      1   <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
     2      2     <PropertyGroup>
     3      3       <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     4      4       <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     5         -    <ProductVersion>9.0.30703</ProductVersion>
            5  +    <ProductVersion>9.0.30729</ProductVersion>
     6      6       <SchemaVersion>2.0</SchemaVersion>
     7      7       <ProjectGuid>{9B4A5CF6-5BE5-4926-ACC7-B729A8C05198}</ProjectGuid>
     8      8       <OutputType>Library</OutputType>
     9      9       <AppDesignerFolder>Properties</AppDesignerFolder>
    10     10       <RootNamespace>SQLite.Designer</RootNamespace>
    11     11       <AssemblyName>SQLite.Designer</AssemblyName>
    12     12       <SignAssembly>false</SignAssembly>
................................................................................
    46     46       <NoWarn>1701;1702;1699;3001</NoWarn>
    47     47       <FileAlignment>512</FileAlignment>
    48     48       <PlatformTarget>x86</PlatformTarget>
    49     49       <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
    50     50       <RegisterOutputPackage>false</RegisterOutputPackage>
    51     51       <RegisterWithCodebase>false</RegisterWithCodebase>
    52     52       <GeneratePkgDefFile>false</GeneratePkgDefFile>
           53  +    <UseVSHostingProcess>false</UseVSHostingProcess>
    53     54     </PropertyGroup>
    54     55     <ItemGroup>
    55     56       <Reference Include="EnvDTE, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
    56     57         <SpecificVersion>False</SpecificVersion>
    57     58         <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\EnvDTE.dll</HintPath>
    58     59       </Reference>
    59     60       <Reference Include="Microsoft.Data.ConnectionUI, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">

Changes to SQLite.Designer/SQLiteAdapterDesigner.cs.

    18     18     /// The purpose of this class is to provide context menus and event support when designing a 
    19     19     /// SQLite DataSet.  Most of the functionality is implemented by MS's VSDesigner object which we
    20     20     /// instantiate through reflection since I don't really have a design-time reference to the object
    21     21     /// and many of the objects in VSDesigner are internal.
    22     22     /// </summary>
    23     23     internal sealed class SQLiteAdapterDesigner : ComponentDesigner, IExtenderProvider
    24     24     {
    25         -    private ComponentDesigner _designer = null;
           25  +    private ComponentDesigner _designer;
    26     26   
    27     27       /// <summary>
    28     28       /// Empty constructor
    29     29       /// </summary>
    30     30       public SQLiteAdapterDesigner()
    31     31       {
    32     32       }

Changes to SQLite.Designer/SQLiteCommandHandler.cs.

    10     10     using System;
    11     11     using Microsoft.VisualStudio.Data;
    12     12     using System.Windows.Forms.Design;
    13     13     using Microsoft.VisualStudio.Shell.Interop;
    14     14     using Microsoft.VisualStudio;
    15     15     using Microsoft.VisualStudio.OLE.Interop;
    16     16     using System.Data.Common;
           17  +  using System.Globalization;
    17     18     using SQLite.Designer.Editors;
    18     19   
    19     20     enum cmdid
    20     21     {
    21     22       CreateTable = 0x3520,
    22     23       CreateView = 0x3521,
    23     24       Alter = 0x3003,
................................................................................
   100    101           object[] parts;
   101    102   
   102    103           for (n = 0; n < items.Length; n++)
   103    104           {
   104    105             parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[n]);
   105    106             if (parts == null) return true;
   106    107   
   107         -          if (parts[2].ToString().StartsWith("sqlite_", StringComparison.InvariantCultureIgnoreCase))
          108  +          if (parts[2].ToString().StartsWith("sqlite_", StringComparison.OrdinalIgnoreCase))
   108    109               return true;
   109    110           }
   110    111           return false;
   111    112         }
   112    113       }
   113    114   
   114    115       private bool SystemIndexSelected
................................................................................
   120    121           object[] parts;
   121    122   
   122    123           for (n = 0; n < items.Length; n++)
   123    124           {
   124    125             parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[n]);
   125    126             if (parts == null) return true;
   126    127   
   127         -          if (parts[2].ToString().StartsWith("sqlite_", StringComparison.InvariantCultureIgnoreCase))
          128  +          if (parts[2].ToString().StartsWith("sqlite_", StringComparison.OrdinalIgnoreCase))
   128    129               return true;
   129    130   
   130    131             if (parts.Length > 3)
   131    132             {
   132         -            if (parts[3].ToString().StartsWith("sqlite_autoindex_", StringComparison.InvariantCultureIgnoreCase)
   133         -              || parts[3].ToString().StartsWith("sqlite_master_PK_", StringComparison.InvariantCultureIgnoreCase))
          133  +            if (parts[3].ToString().StartsWith("sqlite_autoindex_", StringComparison.OrdinalIgnoreCase)
          134  +              || parts[3].ToString().StartsWith("sqlite_master_PK_", StringComparison.OrdinalIgnoreCase))
   134    135                 return true;
   135    136             }
   136    137           }
   137    138           return false;
   138    139         }
   139    140       }
   140    141   
................................................................................
   295    296         object[] parts;
   296    297   
   297    298         for (n = 0; n < items.Length; n++)
   298    299         {
   299    300           parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[n]);
   300    301           if (parts == null) continue;
   301    302   
   302         -        if (System.Windows.Forms.MessageBox.Show(String.Format("Drop table {0} ({1}), are you sure?", parts[2], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
          303  +        if (System.Windows.Forms.MessageBox.Show(String.Format(CultureInfo.InvariantCulture, "Drop table {0} ({1}), are you sure?", parts[2], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
   303    304           {
   304         -          string sql = String.Format("DROP TABLE [{0}].[{1}]", parts[0], parts[2]);
          305  +          string sql = String.Format(CultureInfo.InvariantCulture, "DROP TABLE [{0}].[{1}]", parts[0], parts[2]);
   305    306   
   306    307             DataViewHierarchyAccessor.Connection.Command.ExecuteWithoutResults(sql, (int)System.Data.CommandType.Text, null, 0);
   307    308             DataViewHierarchyAccessor.DropObjectNode(items[n]);
   308    309           }
   309    310           else throw new OperationCanceledException();
   310    311         }
   311    312       }
................................................................................
   317    318         object[] parts;
   318    319   
   319    320         for (n = 0; n < items.Length; n++)
   320    321         {
   321    322           parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[n]);
   322    323           if (parts == null) continue;
   323    324   
   324         -        if (System.Windows.Forms.MessageBox.Show(String.Format("Drop view {0} ({1}), are you sure?", parts[2], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
          325  +        if (System.Windows.Forms.MessageBox.Show(String.Format(CultureInfo.InvariantCulture, "Drop view {0} ({1}), are you sure?", parts[2], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
   325    326           {
   326         -          string sql = String.Format("DROP VIEW [{0}].[{1}]", parts[0], parts[2]);
          327  +          string sql = String.Format(CultureInfo.InvariantCulture, "DROP VIEW [{0}].[{1}]", parts[0], parts[2]);
   327    328   
   328    329             DataViewHierarchyAccessor.Connection.Command.ExecuteWithoutResults(sql, (int)System.Data.CommandType.Text, null, 0);
   329    330             DataViewHierarchyAccessor.DropObjectNode(items[n]);
   330    331           }
   331    332           else throw new OperationCanceledException();
   332    333         }
   333    334       }
................................................................................
   339    340         object[] parts;
   340    341   
   341    342         for (n = 0; n < items.Length; n++)
   342    343         {
   343    344           parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[n]);
   344    345           if (parts == null) continue;
   345    346   
   346         -        if (System.Windows.Forms.MessageBox.Show(String.Format("Drop index {0} ({1}), are you sure?", parts[3], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
          347  +        if (System.Windows.Forms.MessageBox.Show(String.Format(CultureInfo.InvariantCulture, "Drop index {0} ({1}), are you sure?", parts[3], parts[0]), "Confirm delete", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
   347    348           {
   348         -          string sql = String.Format("DROP INDEX [{0}].[{1}]", parts[0], parts[3]);
          349  +          string sql = String.Format(CultureInfo.InvariantCulture, "DROP INDEX [{0}].[{1}]", parts[0], parts[3]);
   349    350   
   350    351             DataViewHierarchyAccessor.Connection.Command.ExecuteWithoutResults(sql, (int)System.Data.CommandType.Text, null, 0);
   351    352             DataViewHierarchyAccessor.DropObjectNode(items[n]);
   352    353           }
   353    354           else throw new OperationCanceledException();
   354    355         }
   355    356       }

Changes to SQLite.Designer/SQLiteConnectionProperties.cs.

    88     88   
    89     89           return false;
    90     90         }
    91     91       }
    92     92   
    93     93       internal static string MapUriPath(string path)
    94     94       {
    95         -      if (path.StartsWith("file://"))
           95  +      if (path.StartsWith("file://", StringComparison.OrdinalIgnoreCase))
    96     96           return path.Substring(7);
    97         -      else if (path.StartsWith("file:"))
           97  +      else if (path.StartsWith("file:", StringComparison.OrdinalIgnoreCase))
    98     98           return path.Substring(5);
    99         -      else if (path.StartsWith("/"))
           99  +      else if (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
   100    100           return path;
   101    101         else
   102    102           return String.Empty;
   103    103       }
   104    104     }
   105    105   }

Changes to SQLite.Designer/SQLiteConnectionStringEditor.cs.

    20     20     /// 
    21     21     /// In order to provide the dropdown list, unless someone knows a better way, I have to use
    22     22     /// the internal VsConnectionManager class since it utilizes some interfaces in the designer
    23     23     /// that are internal to the VSDesigner object.  We instantiate it and utilize it through reflection.
    24     24     /// </summary>
    25     25     internal sealed class SQLiteConnectionStringEditor : ObjectSelectorEditor
    26     26     {
    27         -    private ObjectSelectorEditor.Selector _selector = null;
           27  +    private ObjectSelectorEditor.Selector _selector;
    28     28   
    29         -    private static Type _managerType = null;
           29  +    private static Type _managerType;
    30     30   
    31     31       static SQLiteConnectionStringEditor()
    32     32       {
    33     33         Assembly assm = SQLiteDataAdapterToolboxItem._vsdesigner;
    34     34         if (assm != null)
    35     35         {
    36     36           _managerType = assm.GetType("Microsoft.VSDesigner.Data.VS.VsConnectionManager");
................................................................................
   100    100           string connectionName;
   101    101   
   102    102           for (int n = 0; n < items; n++)
   103    103           {
   104    104             connectionString = (string)_managerType.InvokeMember("GetConnectionString", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public, null, manager, new object[] { n });
   105    105             connectionName = (string)_managerType.InvokeMember("GetConnectionName", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public, null, manager, new object[] { n });
   106    106             dataProvider = (string)_managerType.InvokeMember("GetProvider", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public, null, manager, new object[] { n });
   107         -          if (String.Compare(dataProvider, "System.Data.SQLite", true) == 0)
          107  +          if (String.Compare(dataProvider, "System.Data.SQLite", StringComparison.OrdinalIgnoreCase) == 0)
   108    108             {
   109    109               node = selector.AddNode(connectionName, connectionString, null);
   110    110               
   111         -            if (String.Compare(connectionString, connection.ConnectionString, true) == 0)
          111  +            if (String.Compare(connectionString, connection.ConnectionString, StringComparison.OrdinalIgnoreCase) == 0)
   112    112                 selector.SelectedNode = node;
   113    113             }
   114    114           }
   115    115           selector.AddNode("<New Connection...>", this, null);
   116    116         }
   117    117       }
   118    118     }
   119    119   }

Changes to SQLite.Designer/SQLiteConnectionUIControl.cs.

    10     10     using System;
    11     11     using System.Collections.Generic;
    12     12     using System.ComponentModel;
    13     13     using System.Data;
    14     14     using System.Drawing;
    15     15     using System.Text;
    16     16     using System.Windows.Forms;
           17  +  using System.Globalization;
    17     18     using Microsoft.VisualStudio.Data;
    18     19     using Microsoft.Win32;
    19     20   
    20     21     /// <summary>
    21     22     /// Provides a UI to edit/create SQLite database connections
    22     23     /// </summary>
    23     24     [ToolboxItem(false)]
................................................................................
   105    106           ConnectionProperties.Remove("synchronous");
   106    107         else
   107    108           ConnectionProperties["synchronous"] = sync;
   108    109       }
   109    110   
   110    111       private void pageSizeTextBox_Leave(object sender, EventArgs e)
   111    112       {
   112         -      int n = Convert.ToInt32(pageSizeTextBox.Text);
          113  +      int n = Convert.ToInt32(pageSizeTextBox.Text, CultureInfo.CurrentCulture);
   113    114         ConnectionProperties["page size"] = n;
   114    115       }
   115    116   
   116    117       private void cacheSizeTextbox_Leave(object sender, EventArgs e)
   117    118       {
   118         -      int n = Convert.ToInt32(cacheSizeTextbox.Text);
          119  +      int n = Convert.ToInt32(cacheSizeTextbox.Text, CultureInfo.CurrentCulture);
   119    120         ConnectionProperties["cache size"] = n;
   120    121       }
   121    122   
   122    123       private void fileTextBox_Leave(object sender, EventArgs e)
   123    124       {
   124    125         ConnectionProperties["data source"] = fileTextBox.Text;
   125    126       }
   126    127     }
   127    128   }

Changes to SQLite.Designer/SQLiteDataAdapterToolboxItem.cs.

    13     13     using System.Drawing.Design;
    14     14     using System.Data.Common;
    15     15     using System.Reflection;
    16     16     using System.Collections.Generic;
    17     17     using System.Windows.Forms;
    18     18     using System.Drawing;
    19     19     using System.Runtime.Serialization;
           20  +  using System.Globalization;
    20     21   
    21     22     /// <summary>
    22     23     /// Provides a toolboxitem for a SQLiteDataAdapter.  This is required in order for us to 
    23     24     /// pop up the connection wizard when you drop the tool on a form, and to create the hidden commands
    24     25     /// that are assigned to the data adapter and keep them hidden.  The hiding at runtime of the controls
    25     26     /// is accomplished both here during the creation of the components and in the SQLiteCommandDesigner
    26     27     /// which provides properties to hide the objects when they're supposed to be hidden.
................................................................................
    27     28     /// 
    28     29     /// The connection wizard is instantiated in the VSDesigner through reflection.
    29     30     /// </summary>
    30     31     [Serializable]
    31     32     [ToolboxItem(typeof(SQLiteDataAdapterToolboxItem))]
    32     33     internal sealed class SQLiteDataAdapterToolboxItem : ToolboxItem
    33     34     {
    34         -    private static Type _wizard = null;
           35  +    private static Type _wizard;
    35     36       
    36         -    internal static Assembly _vsdesigner = null;
           37  +    internal static Assembly _vsdesigner;
    37     38   
    38     39       static SQLiteDataAdapterToolboxItem()
    39     40       {
    40     41         _vsdesigner = Assembly.Load("Microsoft.VSDesigner, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
    41     42         _wizard = _vsdesigner.GetType("Microsoft.VSDesigner.Data.VS.DataAdapterWizard");
    42     43       }
    43     44   
................................................................................
    65     66         DbProviderFactory fact = DbProviderFactories.GetFactory("System.Data.SQLite");
    66     67   
    67     68         DbDataAdapter dataAdapter = fact.CreateDataAdapter();
    68     69         IContainer container = host.Container;
    69     70         
    70     71         using (DbCommand adapterCommand = fact.CreateCommand())
    71     72         {
           73  +        ICloneable adapter = (ICloneable)adapterCommand;
           74  +
    72     75           adapterCommand.DesignTimeVisible = false;
    73         -        dataAdapter.SelectCommand = (DbCommand)((ICloneable)adapterCommand).Clone();
           76  +        dataAdapter.SelectCommand = (DbCommand)adapter.Clone();
    74     77           container.Add(dataAdapter.SelectCommand, GenerateName(container, "SelectCommand"));
    75     78   
    76         -        dataAdapter.InsertCommand = (DbCommand)((ICloneable)adapterCommand).Clone();
           79  +        dataAdapter.InsertCommand = (DbCommand)adapter.Clone();
    77     80           container.Add(dataAdapter.InsertCommand, GenerateName(container, "InsertCommand"));
    78     81   
    79         -        dataAdapter.UpdateCommand = (DbCommand)((ICloneable)adapterCommand).Clone();
           82  +        dataAdapter.UpdateCommand = (DbCommand)adapter.Clone();
    80     83           container.Add(dataAdapter.UpdateCommand, GenerateName(container, "UpdateCommand"));
    81     84   
    82         -        dataAdapter.DeleteCommand = (DbCommand)((ICloneable)adapterCommand).Clone();
           85  +        dataAdapter.DeleteCommand = (DbCommand)adapter.Clone();
    83     86           container.Add(dataAdapter.DeleteCommand, GenerateName(container, "DeleteCommand"));
    84     87         }
    85     88   
    86     89         ITypeResolutionService typeResService = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService));
    87     90         if (typeResService != null)
    88     91         {
    89     92           typeResService.ReferenceAssembly(dataAdapter.GetType().Assembly.GetName());
................................................................................
   120    123       private static string GenerateName(IContainer container, string baseName)
   121    124       {
   122    125         ComponentCollection coll = container.Components;
   123    126         string uniqueName;
   124    127         int n = 1;
   125    128         do
   126    129         {
   127         -        uniqueName = String.Format("sqlite{0}{1}", baseName, n++);
          130  +        uniqueName = String.Format(CultureInfo.InvariantCulture, "sqlite{0}{1}", baseName, n++);
   128    131         } while (coll[uniqueName] != null);
   129    132   
   130    133         return uniqueName;
   131    134       }
   132    135     }
   133    136   }

Changes to SQLite.Designer/SQLiteDataViewSupport.cs.

     6      6    ********************************************************/
     7      7   
     8      8   namespace SQLite.Designer
     9      9   {
    10     10     using System;
    11     11     using System.Collections.Generic;
    12     12     using System.Text;
           13  +  using System.Globalization;
    13     14     using Microsoft.VisualStudio.Data;
    14     15     using Microsoft.VisualStudio.OLE.Interop;
    15     16     using Microsoft.VisualStudio.Data.AdoDotNet;
    16     17   
    17     18     /// <summary>
    18     19     /// Provides DataViewSupport with a location where the XML file is for the Server Explorer's view.
    19     20     /// </summary>
    20     21     internal sealed class SQLiteDataViewSupport : DataViewSupport
    21     22     {
    22     23       public SQLiteDataViewSupport()
    23         -      : base(String.Format("SQLite.Designer.SQLiteDataViewSupport{0}", GetVSVersion()), typeof(SQLiteDataViewSupport).Assembly)
           24  +      : base(String.Format(CultureInfo.InvariantCulture, "SQLite.Designer.SQLiteDataViewSupport{0}", GetVSVersion()), typeof(SQLiteDataViewSupport).Assembly)
    24     25       {
    25     26       }
    26     27   
    27     28       private static string GetVSVersion()
    28     29       {
    29     30         switch (System.Diagnostics.FileVersionInfo.GetVersionInfo(Environment.GetCommandLineArgs()[0]).FileMajorPart)
    30     31         {

Changes to SQLite.Designer/TableNameDialog.cs.

    22     22       {
    23     23       }
    24     24   
    25     25       public TableNameDialog(string type, string defaultName)
    26     26       {
    27     27         InitializeComponent();
    28     28         Text = Text.Replace("%", type);
    29         -      label1.Text = label1.Text.Replace("%", type.ToLower());
           29  +      label1.Text = label1.Text.Replace("%", type.ToLowerInvariant());
    30     30         _name.Text = defaultName;
    31     31       }
    32     32   
    33     33       public string TableName
    34     34       {
    35     35         get { return _name.Text; }
    36     36         set { _name.Text = value; }

Changes to SQLite.Interop/SQLite.Interop.rc.

    49     49   
    50     50   /////////////////////////////////////////////////////////////////////////////
    51     51   //
    52     52   // Version
    53     53   //
    54     54   
    55     55   VS_VERSION_INFO VERSIONINFO
    56         - FILEVERSION 1,0,64,0
           56  + FILEVERSION 1,0,66,0
    57     57    PRODUCTVERSION 1,0,0,0
    58     58    FILEFLAGSMASK 0x17L
    59     59   #ifdef _DEBUG
    60     60    FILEFLAGS 0x1L
    61     61   #else
    62     62    FILEFLAGS 0x0L
    63     63   #endif
................................................................................
    67     67   BEGIN
    68     68       BLOCK "StringFileInfo"
    69     69       BEGIN
    70     70           BLOCK "040904b0"
    71     71           BEGIN
    72     72               VALUE "Comments", "http://sqlite.phxsoftware.com"
    73     73               VALUE "FileDescription", "System.Data.SQLite Interop Library"
    74         -            VALUE "FileVersion", "1.0.64.0"
           74  +            VALUE "FileVersion", "1.0.66.0"
    75     75               VALUE "InternalName", "SQLite.Interop.DLL"
    76     76               VALUE "LegalCopyright", "Released to the public domain"
    77         -            VALUE "OriginalFilename", "SQLite3.DLL 3.6.16"
           77  +            VALUE "OriginalFilename", "SQLite3.DLL 3.6.23.1"
    78     78               VALUE "ProductName", "System.Data.SQLite"
    79     79               VALUE "ProductVersion", "1.0"
    80     80           END
    81     81       END
    82     82       BLOCK "VarFileInfo"
    83     83       BEGIN
    84     84           VALUE "Translation", 0x409, 1200

Changes to SQLite.Interop/SQLite.Interop.vcproj.

   160    160   				Name="VCPreLinkEventTool"
   161    161   				CommandLine=""
   162    162   			/>
   163    163   			<Tool
   164    164   				Name="VCLinkerTool"
   165    165   				IgnoreImportLibrary="true"
   166    166   				AdditionalOptions=" /subsystem:windowsce,4.20 /ARMPADCODE"
   167         -				OutputFile="../bin/CompactFramework/$(InputName).064.DLL"
          167  +				OutputFile="../bin/CompactFramework/$(InputName).066.DLL"
   168    168   				AdditionalLibraryDirectories=""
   169    169   				IgnoreDefaultLibraryNames=""
   170    170   				ModuleDefinitionFile="src\sqlite3.def"
   171    171   				AddModuleNamesToAssembly=""
   172    172   				EmbedManagedResourceFile=""
   173    173   				EntryPointSymbol=""
   174    174   				MergeSections=""
................................................................................
   500    500   			<Tool
   501    501   				Name="VCPreLinkEventTool"
   502    502   			/>
   503    503   			<Tool
   504    504   				Name="VCLinkerTool"
   505    505   				IgnoreImportLibrary="true"
   506    506   				AdditionalOptions=" /subsystem:windowsce,4.20 /ARMPADCODE"
   507         -				OutputFile="../bin/CompactFramework/$(InputName).064.DLL"
          507  +				OutputFile="../bin/CompactFramework/$(InputName).065.DLL"
   508    508   				AdditionalLibraryDirectories=""
   509    509   				IgnoreDefaultLibraryNames=""
   510    510   				ModuleDefinitionFile="src\sqlite3.def"
   511    511   				AddModuleNamesToAssembly=""
   512    512   				EmbedManagedResourceFile=""
   513    513   				GenerateDebugInformation="true"
   514    514   				SubSystem="8"
................................................................................
  1028   1028   			/>
  1029   1029   			<Tool
  1030   1030   				Name="VCPostBuildEventTool"
  1031   1031   			/>
  1032   1032   		</Configuration>
  1033   1033   	</Configurations>
  1034   1034   	<References>
  1035         -		<AssemblyReference
  1036         -			RelativePath="System.Drawing.dll"
  1037         -			AssemblyName="System.Drawing, Version=2.0.0.0, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"
  1038         -			MinFrameworkVersion="131072"
  1039         -		/>
  1040   1035   	</References>
  1041   1036   	<Files>
  1042   1037   		<Filter
  1043   1038   			Name="Header Files"
  1044   1039   			Filter="h;hpp;hxx;hm;inl;inc;xsd"
  1045   1040   			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
  1046   1041   			>

Changes to SQLite.Interop/crypt.c.

     1      1   #ifndef SQLITE_OMIT_DISKIO
     2      2   #ifdef SQLITE_HAS_CODEC
     3      3   
     4         -#ifdef SQLITE_DEBUG
     5         -#include "splitsource\pager.c"
     6         -#endif
            4  +//#ifdef SQLITE_DEBUG
            5  +//#include "splitsource\pager.c"
            6  +//#endif
     7      7   
     8      8   #include <windows.h>
     9      9   #include <wincrypt.h>
    10     10   
    11     11   // Extra padding before and after the cryptographic buffer
    12     12   #define CRYPT_OFFSET 8
    13     13   
................................................................................
    85     85     }
    86     86   
    87     87     // Figure out how big to make our spare crypt block
    88     88     CryptEncrypt(hKey, 0, TRUE, 0, NULL, &pBlock->dwCryptSize, pBlock->dwCryptSize * 2);
    89     89     pBlock->pvCrypt = sqlite3_malloc(pBlock->dwCryptSize + (CRYPT_OFFSET * 2));
    90     90     if (!pBlock->pvCrypt)
    91     91     {
    92         -    sqlite3_free(pBlock);
           92  +    // We created a new block in here, so free it.  Otherwise leave the original intact
           93  +    if (pBlock != pExisting) 
           94  +      sqlite3_free(pBlock);
           95  +
    93     96       return NULL;
    94     97     }
    95     98   
    96     99     return pBlock;
    97    100   }
    98    101   
    99    102   // Destroy a cryptographic context and any buffers and keys allocated therein
................................................................................
   123    126   }
   124    127   
   125    128   void sqlite3CodecSizeChange(void *pArg, int pageSize, int reservedSize)
   126    129   {
   127    130     LPCRYPTBLOCK pBlock = (LPCRYPTBLOCK)pArg;
   128    131   
   129    132     if (pBlock->dwPageSize != pageSize)
   130         -      CreateCryptBlock(pBlock->hReadKey, pBlock->pPager, pageSize, pBlock);
          133  +  {
          134  +    CreateCryptBlock(pBlock->hReadKey, pBlock->pPager, pageSize, pBlock);
          135  +    // If this fails, pvCrypt will be NULL, and the next time sqlite3Codec() is called, it will result in an error
          136  +  }
   131    137   }
   132    138   
   133    139   // Encrypt/Decrypt functionality, called by pager.c
   134    140   void * sqlite3Codec(void *pArg, void *data, Pgno nPageNum, int nMode)
   135    141   {
   136    142     LPCRYPTBLOCK pBlock = (LPCRYPTBLOCK)pArg;
   137    143     DWORD dwPageSize;
   138    144     LPVOID pvTemp;
   139    145   
   140    146     if (!pBlock) return data;
   141         -
   142         -  //// Make sure the page size for the pager is still the same as the page size
   143         -  //// for the cryptblock.  If the user changed it, we need to adjust!
   144         -  //if (nMode != 2)
   145         -  //{
   146         -  //  if (pBlock->pPager->pageSize != pBlock->dwPageSize)
   147         -  //  {
   148         -  //    // Update the cryptblock to reflect the new page size
   149         -  //    CreateCryptBlock(pBlock->hReadKey, pBlock->pPager, pBlock);
   150         -  //  }
   151         -  //}
          147  +  if (pBlock->pvCrypt == NULL) return NULL; // This only happens if CreateCryptBlock() failed to make scratch space
   152    148   
   153    149     switch(nMode)
   154    150     {
   155    151     case 0: // Undo a "case 7" journal file encryption
   156    152     case 2: // Reload a page
   157    153     case 3: // Load a page
   158    154       if (!pBlock->hReadKey) break;
................................................................................
   238    234   }
   239    235   
   240    236   // Called by sqlite and sqlite3_key_interop to attach a key to a database.
   241    237   int sqlite3CodecAttach(sqlite3 *db, int nDb, const void *pKey, int nKeyLen)
   242    238   {
   243    239     int rc = SQLITE_ERROR;
   244    240     HCRYPTKEY hKey = 0;
   245         -  Pager *p = sqlite3BtreePager(db->aDb[nDb].pBt);
   246    241   
   247    242     // No key specified, could mean either use the main db's encryption or no encryption
   248    243     if (!pKey || !nKeyLen)
   249    244     {
   250    245       if (!nDb)
   251    246       {
   252    247         return SQLITE_OK; // Main database, no key specified so not encrypted
   253    248       }
   254    249       else // Attached database, use the main database's key
   255    250       {
   256    251         // Get the encryption block for the main database and attempt to duplicate the key
   257    252         // for use by the attached database
          253  +      Pager *p = sqlite3BtreePager(db->aDb[0].pBt);
   258    254         LPCRYPTBLOCK pBlock = (LPCRYPTBLOCK)sqlite3pager_get_codecarg(p);
   259    255   
   260    256         if (!pBlock) return SQLITE_OK; // Main database is not encrypted so neither will be any attached database
   261    257         if (!pBlock->hReadKey) return SQLITE_OK; // Not encrypted
   262    258   
   263    259         if (!CryptDuplicateKey(pBlock->hReadKey, NULL, 0, &hKey))
   264    260           return rc; // Unable to duplicate the key
................................................................................
   273    269         return rc;
   274    270       }
   275    271     }
   276    272   
   277    273     // Create a new encryption block and assign the codec to the new attached database
   278    274     if (hKey)
   279    275     {
          276  +    Pager *p = sqlite3BtreePager(db->aDb[nDb].pBt);
   280    277       LPCRYPTBLOCK pBlock = CreateCryptBlock(hKey, p, -1, NULL);
          278  +    if (!pBlock) return SQLITE_NOMEM;
          279  +
   281    280       sqlite3PagerSetCodec(p, sqlite3Codec, sqlite3CodecSizeChange, sqlite3CodecFree, pBlock);
   282    281       //db->aDb[nDb].pAux = pBlock;
   283    282       //db->aDb[nDb].xFreeAux = DestroyCryptBlock;
   284    283   
   285    284       rc = SQLITE_OK;
   286    285     }
   287    286     return rc;
................................................................................
   399    398     }
   400    399   
   401    400     // If the readkey and writekey are both empty, there's no need for a codec on this
   402    401     // pager anymore.  Destroy the crypt block and remove the codec from the pager.
   403    402     if (!pBlock->hReadKey && !pBlock->hWriteKey)
   404    403     {
   405    404       sqlite3PagerSetCodec(p, NULL, NULL, NULL, NULL);
   406         -    //db->aDb[0].pAux = NULL;
   407         -    //db->aDb[0].xFreeAux = NULL;
   408         -    sqlite3CodecFree(pBlock);
   409    405     }
   410    406   
   411    407     return rc;
   412    408   }
   413    409   
   414    410   #endif // SQLITE_HAS_CODEC
   415    411   
   416    412   #endif // SQLITE_OMIT_DISKIO

Changes to SQLite.Interop/interop.c.

   437    437       if(ret)
   438    438         break;
   439    439   
   440    440       if(pC->rowidIsValid)
   441    441       {
   442    442         *prowid = pC->lastRowid;
   443    443       }
   444         -    else if(pC->pseudoTable)
          444  +    else if(pC->pseudoTableReg > 0)
   445    445       {
   446         -      *prowid = pC->iKey;
          446  +      ret = SQLITE_ERROR;
          447  +      break;
   447    448       }
   448    449       else if(pC->nullRow || pC->pCursor==0)
   449    450       {
   450    451         ret = SQLITE_ERROR;
   451    452         break;
   452    453       }
   453    454       else

Changes to SQLite.Interop/src/sqlite3.c.

more than 10,000 changes

Changes to SQLite.Interop/src/sqlite3.def.

    49     49   sqlite3_column_table_name
    50     50   sqlite3_column_table_name16
    51     51   sqlite3_column_text
    52     52   sqlite3_column_text16
    53     53   sqlite3_column_type
    54     54   sqlite3_column_value
    55     55   sqlite3_commit_hook
           56  +sqlite3_compileoption_get
           57  +sqlite3_compileoption_used
    56     58   sqlite3_complete
    57     59   sqlite3_complete16
    58     60   sqlite3_config
    59     61   sqlite3_context_db_handle
    60     62   sqlite3_create_collation
    61     63   sqlite3_create_collation16
    62     64   sqlite3_create_collation_v2
................................................................................
    90     92   sqlite3_initialize
    91     93   sqlite3_interrupt
    92     94   sqlite3_last_insert_rowid
    93     95   sqlite3_libversion
    94     96   sqlite3_libversion_number
    95     97   sqlite3_limit
    96     98   sqlite3_load_extension
           99  +sqlite3_log
    97    100   sqlite3_malloc
    98    101   sqlite3_memory_alarm
    99    102   sqlite3_memory_highwater
   100    103   sqlite3_memory_used
   101    104   sqlite3_mprintf
   102    105   sqlite3_mutex_alloc
   103    106   sqlite3_mutex_enter
................................................................................
   141    144   sqlite3_rollback_hook
   142    145   sqlite3_set_authorizer
   143    146   sqlite3_set_auxdata
   144    147   sqlite3_shutdown
   145    148   sqlite3_sleep
   146    149   sqlite3_snprintf
   147    150   sqlite3_soft_heap_limit
          151  +sqlite3_sourceid
   148    152   sqlite3_sql
   149    153   sqlite3_status
   150    154   sqlite3_step
   151    155   sqlite3_stmt_status
          156  +sqlite3_strnicmp
   152    157   sqlite3_table_column_metadata
   153    158   sqlite3_test_control
   154    159   sqlite3_thread_cleanup
   155    160   sqlite3_threadsafe
   156    161   sqlite3_total_changes
   157    162   sqlite3_trace
   158    163   sqlite3_transfer_bindings
................................................................................
   171    176   sqlite3_value_text16le
   172    177   sqlite3_value_type
   173    178   sqlite3_version
   174    179   sqlite3_vfs_find
   175    180   sqlite3_vfs_register
   176    181   sqlite3_vfs_unregister
   177    182   sqlite3_vmprintf
          183  +sqlite3_win32_mbcs_to_utf8
   178    184   sqlite3_key
   179    185   sqlite3_rekey
   180         -sqlite3_win32_mbcs_to_utf8

Changes to SQLite.Interop/src/sqlite3.h.

    14     14   ** or constant definition does not appear in this file, then it is
    15     15   ** not a published API of SQLite, is subject to change without
    16     16   ** notice, and should not be referenced by programs that use SQLite.
    17     17   **
    18     18   ** Some of the definitions that are in this file are marked as
    19     19   ** "experimental".  Experimental interfaces are normally new
    20     20   ** features recently added to SQLite.  We do not anticipate changes
    21         -** to experimental interfaces but reserve to make minor changes if
    22         -** experience from use "in the wild" suggest such changes are prudent.
           21  +** to experimental interfaces but reserve the right to make minor changes
           22  +** if experience from use "in the wild" suggest such changes are prudent.
    23     23   **
    24     24   ** The official C-language API documentation for SQLite is derived
    25     25   ** from comments in this file.  This file is the authoritative source
    26     26   ** on how SQLite interfaces are suppose to operate.
    27     27   **
    28     28   ** The name of this file under configuration management is "sqlite.h.in".
    29     29   ** The makefile makes some minor changes to this file (such as inserting
    30     30   ** the version number) and changes its name to "sqlite3.h" as
    31     31   ** part of the build process.
    32         -**
    33         -** @(#) $Id: sqlite3.h,v 1.41 2009/06/29 22:59:09 rmsimpson Exp $
    34     32   */
    35     33   #ifndef _SQLITE3_H_
    36     34   #define _SQLITE3_H_
    37     35   #include <stdarg.h>     /* Needed for the definition of va_list */
    38     36   
    39     37   /*
    40     38   ** Make sure we can call this stuff from C++.
................................................................................
    46     44   
    47     45   /*
    48     46   ** Add the ability to override 'extern'
    49     47   */
    50     48   #ifndef SQLITE_EXTERN
    51     49   # define SQLITE_EXTERN extern
    52     50   #endif
           51  +
           52  +#ifndef SQLITE_API
           53  +# define SQLITE_API
           54  +#endif
           55  +
    53     56   
    54     57   /*
    55     58   ** These no-op macros are used in front of interfaces to mark those
    56     59   ** interfaces as either deprecated or experimental.  New applications
    57         -** should not use deprecated intrfaces - they are support for backwards
           60  +** should not use deprecated interfaces - they are support for backwards
    58     61   ** compatibility only.  Application writers should be aware that
    59     62   ** experimental interfaces are subject to change in point releases.
    60     63   **
    61     64   ** These macros used to resolve to various kinds of compiler magic that
    62     65   ** would generate warning messages when they were used.  But that
    63     66   ** compiler magic ended up generating such a flurry of bug reports
    64     67   ** that we have taken it all out and gone back to using simple
................................................................................
    74     77   # undef SQLITE_VERSION
    75     78   #endif
    76     79   #ifdef SQLITE_VERSION_NUMBER
    77     80   # undef SQLITE_VERSION_NUMBER
    78     81   #endif
    79     82   
    80     83   /*
    81         -** CAPI3REF: Compile-Time Library Version Numbers {H10010} <S60100>
    82         -**
    83         -** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in
    84         -** the sqlite3.h file specify the version of SQLite with which
    85         -** that header file is associated.
    86         -**
    87         -** The "version" of SQLite is a string of the form "X.Y.Z".
    88         -** The phrase "alpha" or "beta" might be appended after the Z.
    89         -** The X value is major version number always 3 in SQLite3.
    90         -** The X value only changes when backwards compatibility is
    91         -** broken and we intend to never break backwards compatibility.
    92         -** The Y value is the minor version number and only changes when
    93         -** there are major feature enhancements that are forwards compatible
    94         -** but not backwards compatible.
    95         -** The Z value is the release number and is incremented with
    96         -** each release but resets back to 0 whenever Y is incremented.
    97         -**
    98         -** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()].
    99         -**
   100         -** Requirements: [H10011] [H10014]
   101         -*/
   102         -#define SQLITE_VERSION         "3.6.16"
   103         -#define SQLITE_VERSION_NUMBER  3006016
   104         -
   105         -/*
   106         -** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
   107         -** KEYWORDS: sqlite3_version
   108         -**
   109         -** These features provide the same information as the [SQLITE_VERSION]
   110         -** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated
   111         -** with the library instead of the header file.  Cautious programmers might
   112         -** include a check in their application to verify that
   113         -** sqlite3_libversion_number() always returns the value
   114         -** [SQLITE_VERSION_NUMBER].
   115         -**
   116         -** The sqlite3_libversion() function returns the same information as is
   117         -** in the sqlite3_version[] string constant.  The function is provided
   118         -** for use in DLLs since DLL users usually do not have direct access to string
   119         -** constants within the DLL.
   120         -**
   121         -** Requirements: [H10021] [H10022] [H10023]
   122         -*/
   123         -SQLITE_EXTERN const char sqlite3_version[];
   124         -const char *sqlite3_libversion(void);
   125         -int sqlite3_libversion_number(void);
   126         -
   127         -/*
   128         -** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100>
           84  +** CAPI3REF: Compile-Time Library Version Numbers
           85  +**
           86  +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
           87  +** evaluates to a string literal that is the SQLite version in the
           88  +** format "X.Y.Z" where X is the major version number (always 3 for
           89  +** SQLite3) and Y is the minor version number and Z is the release number.)^
           90  +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
           91  +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
           92  +** numbers used in [SQLITE_VERSION].)^
           93  +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
           94  +** be larger than the release from which it is derived.  Either Y will
           95  +** be held constant and Z will be incremented or else Y will be incremented
           96  +** and Z will be reset to zero.
           97  +**
           98  +** Since version 3.6.18, SQLite source code has been stored in the
           99  +** <a href="http://www.fossil-scm.org/">Fossil configuration management
          100  +** system</a>.  ^The SQLITE_SOURCE_ID macro evalutes to
          101  +** a string which identifies a particular check-in of SQLite
          102  +** within its configuration management system.  ^The SQLITE_SOURCE_ID
          103  +** string contains the date and time of the check-in (UTC) and an SHA1
          104  +** hash of the entire source tree.
          105  +**
          106  +** See also: [sqlite3_libversion()],
          107  +** [sqlite3_libversion_number()], [sqlite3_sourceid()],
          108  +** [sqlite_version()] and [sqlite_source_id()].
          109  +*/
          110  +#define SQLITE_VERSION        "3.6.23.1"
          111  +#define SQLITE_VERSION_NUMBER 3006023
          112  +#define SQLITE_SOURCE_ID      "2010-03-26 22:28:06 b078b588d617e07886ad156e9f54ade6d823568e"
          113  +
          114  +/*
          115  +** CAPI3REF: Run-Time Library Version Numbers
          116  +** KEYWORDS: sqlite3_version, sqlite3_sourceid
          117  +**
          118  +** These interfaces provide the same information as the [SQLITE_VERSION],
          119  +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
          120  +** but are associated with the library instead of the header file.  ^(Cautious
          121  +** programmers might include assert() statements in their application to
          122  +** verify that values returned by these interfaces match the macros in
          123  +** the header, and thus insure that the application is
          124  +** compiled with matching library and header files.
          125  +**
          126  +** <blockquote><pre>
          127  +** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
          128  +** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
          129  +** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
          130  +** </pre></blockquote>)^
          131  +**
          132  +** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
          133  +** macro.  ^The sqlite3_libversion() function returns a pointer to the
          134  +** to the sqlite3_version[] string constant.  The sqlite3_libversion()
          135  +** function is provided for use in DLLs since DLL users usually do not have
          136  +** direct access to string constants within the DLL.  ^The
          137  +** sqlite3_libversion_number() function returns an integer equal to
          138  +** [SQLITE_VERSION_NUMBER].  ^The sqlite3_sourceid() function returns 
          139  +** a pointer to a string constant whose value is the same as the 
          140  +** [SQLITE_SOURCE_ID] C preprocessor macro.
          141  +**
          142  +** See also: [sqlite_version()] and [sqlite_source_id()].
          143  +*/
          144  +SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
          145  +SQLITE_API const char *sqlite3_libversion(void);
          146  +SQLITE_API const char *sqlite3_sourceid(void);
          147  +SQLITE_API int sqlite3_libversion_number(void);
          148  +
          149  +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
          150  +/*
          151  +** CAPI3REF: Run-Time Library Compilation Options Diagnostics
          152  +**
          153  +** ^The sqlite3_compileoption_used() function returns 0 or 1 
          154  +** indicating whether the specified option was defined at 
          155  +** compile time.  ^The SQLITE_ prefix may be omitted from the 
          156  +** option name passed to sqlite3_compileoption_used().  
          157  +**
          158  +** ^The sqlite3_compileoption_get() function allows interating
          159  +** over the list of options that were defined at compile time by
          160  +** returning the N-th compile time option string.  ^If N is out of range,
          161  +** sqlite3_compileoption_get() returns a NULL pointer.  ^The SQLITE_ 
          162  +** prefix is omitted from any strings returned by 
          163  +** sqlite3_compileoption_get().
          164  +**
          165  +** ^Support for the diagnostic functions sqlite3_compileoption_used()
          166  +** and sqlite3_compileoption_get() may be omitted by specifing the 
          167  +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
          168  +**
          169  +** See also: SQL functions [sqlite_compileoption_used()] and
          170  +** [sqlite_compileoption_get()] and the [compile_options pragma].
          171  +*/
          172  +SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
          173  +SQLITE_API const char *sqlite3_compileoption_get(int N);
          174  +#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
          175  +
          176  +/*
          177  +** CAPI3REF: Test To See If The Library Is Threadsafe
          178  +**
          179  +** ^The sqlite3_threadsafe() function returns zero if and only if
          180  +** SQLite was compiled mutexing code omitted due to the
          181  +** [SQLITE_THREADSAFE] compile-time option being set to 0.
   129    182   **
   130    183   ** SQLite can be compiled with or without mutexes.  When
   131         -** the [SQLITE_THREADSAFE] C preprocessor macro 1 or 2, mutexes
          184  +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
   132    185   ** are enabled and SQLite is threadsafe.  When the
   133    186   ** [SQLITE_THREADSAFE] macro is 0, 
   134    187   ** the mutexes are omitted.  Without the mutexes, it is not safe
   135    188   ** to use SQLite concurrently from more than one thread.
   136    189   **
   137    190   ** Enabling mutexes incurs a measurable performance penalty.
   138    191   ** So if speed is of utmost importance, it makes sense to disable
   139    192   ** the mutexes.  But for maximum safety, mutexes should be enabled.
   140         -** The default behavior is for mutexes to be enabled.
          193  +** ^The default behavior is for mutexes to be enabled.
   141    194   **
   142         -** This interface can be used by a program to make sure that the
          195  +** This interface can be used by an application to make sure that the
   143    196   ** version of SQLite that it is linking against was compiled with
   144    197   ** the desired setting of the [SQLITE_THREADSAFE] macro.
   145    198   **
   146    199   ** This interface only reports on the compile-time mutex setting
   147    200   ** of the [SQLITE_THREADSAFE] flag.  If SQLite is compiled with
   148         -** SQLITE_THREADSAFE=1 then mutexes are enabled by default but
          201  +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
   149    202   ** can be fully or partially disabled using a call to [sqlite3_config()]
   150    203   ** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
   151         -** or [SQLITE_CONFIG_MUTEX].  The return value of this function shows
   152         -** only the default compile-time setting, not any run-time changes
   153         -** to that setting.
          204  +** or [SQLITE_CONFIG_MUTEX].  ^(The return value of the
          205  +** sqlite3_threadsafe() function shows only the compile-time setting of
          206  +** thread safety, not any run-time changes to that setting made by
          207  +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
          208  +** is unchanged by calls to sqlite3_config().)^
   154    209   **
   155    210   ** See the [threading mode] documentation for additional information.
   156         -**
   157         -** Requirements: [H10101] [H10102]
   158    211   */
   159         -int sqlite3_threadsafe(void);
          212  +SQLITE_API int sqlite3_threadsafe(void);
   160    213   
   161    214   /*
   162         -** CAPI3REF: Database Connection Handle {H12000} <S40200>
          215  +** CAPI3REF: Database Connection Handle
   163    216   ** KEYWORDS: {database connection} {database connections}
   164    217   **
   165    218   ** Each open SQLite database is represented by a pointer to an instance of
   166    219   ** the opaque structure named "sqlite3".  It is useful to think of an sqlite3
   167    220   ** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and
   168    221   ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
   169    222   ** is its destructor.  There are many other interfaces (such as
................................................................................
   170    223   ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
   171    224   ** [sqlite3_busy_timeout()] to name but three) that are methods on an
   172    225   ** sqlite3 object.
   173    226   */
   174    227   typedef struct sqlite3 sqlite3;
   175    228   
   176    229   /*
   177         -** CAPI3REF: 64-Bit Integer Types {H10200} <S10110>
          230  +** CAPI3REF: 64-Bit Integer Types
   178    231   ** KEYWORDS: sqlite_int64 sqlite_uint64
   179    232   **
   180    233   ** Because there is no cross-platform way to specify 64-bit integer types
   181    234   ** SQLite includes typedefs for 64-bit signed and unsigned integers.
   182    235   **
   183    236   ** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
   184    237   ** The sqlite_int64 and sqlite_uint64 types are supported for backwards
   185    238   ** compatibility only.
   186    239   **
   187         -** Requirements: [H10201] [H10202]
          240  +** ^The sqlite3_int64 and sqlite_int64 types can store integer values
          241  +** between -9223372036854775808 and +9223372036854775807 inclusive.  ^The
          242  +** sqlite3_uint64 and sqlite_uint64 types can store integer values 
          243  +** between 0 and +18446744073709551615 inclusive.
   188    244   */
   189    245   #ifdef SQLITE_INT64_TYPE
   190    246     typedef SQLITE_INT64_TYPE sqlite_int64;
   191    247     typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
   192    248   #elif defined(_MSC_VER) || defined(__BORLANDC__)
   193    249     typedef __int64 sqlite_int64;
   194    250     typedef unsigned __int64 sqlite_uint64;
................................................................................
   204    260   ** substitute integer for floating-point.
   205    261   */
   206    262   #ifdef SQLITE_OMIT_FLOATING_POINT
   207    263   # define double sqlite3_int64
   208    264   #endif
   209    265   
   210    266   /*
   211         -** CAPI3REF: Closing A Database Connection {H12010} <S30100><S40200>
          267  +** CAPI3REF: Closing A Database Connection
   212    268   **
   213         -** This routine is the destructor for the [sqlite3] object.
          269  +** ^The sqlite3_close() routine is the destructor for the [sqlite3] object.
          270  +** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is
          271  +** successfullly destroyed and all associated resources are deallocated.
   214    272   **
   215         -** Applications should [sqlite3_finalize | finalize] all [prepared statements]
          273  +** Applications must [sqlite3_finalize | finalize] all [prepared statements]
   216    274   ** and [sqlite3_blob_close | close] all [BLOB handles] associated with
   217         -** the [sqlite3] object prior to attempting to close the object.
   218         -** The [sqlite3_next_stmt()] interface can be used to locate all
   219         -** [prepared statements] associated with a [database connection] if desired.
   220         -** Typical code might look like this:
          275  +** the [sqlite3] object prior to attempting to close the object.  ^If
          276  +** sqlite3_close() is called on a [database connection] that still has
          277  +** outstanding [prepared statements] or [BLOB handles], then it returns
          278  +** SQLITE_BUSY.
   221    279   **
   222         -** <blockquote><pre>
   223         -** sqlite3_stmt *pStmt;
   224         -** while( (pStmt = sqlite3_next_stmt(db, 0))!=0 ){
   225         -** &nbsp;   sqlite3_finalize(pStmt);
   226         -** }
   227         -** </pre></blockquote>
   228         -**
   229         -** If [sqlite3_close()] is invoked while a transaction is open,
          280  +** ^If [sqlite3_close()] is invoked while a transaction is open,
   230    281   ** the transaction is automatically rolled back.
   231    282   **
   232    283   ** The C parameter to [sqlite3_close(C)] must be either a NULL
   233    284   ** pointer or an [sqlite3] object pointer obtained
   234    285   ** from [sqlite3_open()], [sqlite3_open16()], or
   235    286   ** [sqlite3_open_v2()], and not previously closed.
   236         -**
   237         -** Requirements:
   238         -** [H12011] [H12012] [H12013] [H12014] [H12015] [H12019]
          287  +** ^Calling sqlite3_close() with a NULL pointer argument is a 
          288  +** harmless no-op.
   239    289   */
   240         -int sqlite3_close(sqlite3 *);
          290  +SQLITE_API int sqlite3_close(sqlite3 *);
   241    291   
   242    292   /*
   243    293   ** The type for a callback function.
   244    294   ** This is legacy and deprecated.  It is included for historical
   245    295   ** compatibility and is not documented.
   246    296   */
   247    297   typedef int (*sqlite3_callback)(void*,int,char**, char**);
   248    298   
   249    299   /*
   250         -** CAPI3REF: One-Step Query Execution Interface {H12100} <S10000>
   251         -**
   252         -** The sqlite3_exec() interface is a convenient way of running one or more
   253         -** SQL statements without having to write a lot of C code.  The UTF-8 encoded
   254         -** SQL statements are passed in as the second parameter to sqlite3_exec().
   255         -** The statements are evaluated one by one until either an error or
   256         -** an interrupt is encountered, or until they are all done.  The 3rd parameter
   257         -** is an optional callback that is invoked once for each row of any query
   258         -** results produced by the SQL statements.  The 5th parameter tells where
   259         -** to write any error messages.
   260         -**
   261         -** The error message passed back through the 5th parameter is held
   262         -** in memory obtained from [sqlite3_malloc()].  To avoid a memory leak,
   263         -** the calling application should call [sqlite3_free()] on any error
   264         -** message returned through the 5th parameter when it has finished using
   265         -** the error message.
   266         -**
   267         -** If the SQL statement in the 2nd parameter is NULL or an empty string
   268         -** or a string containing only whitespace and comments, then no SQL
   269         -** statements are evaluated and the database is not changed.
   270         -**
   271         -** The sqlite3_exec() interface is implemented in terms of
   272         -** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
   273         -** The sqlite3_exec() routine does nothing to the database that cannot be done
   274         -** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].
   275         -**
   276         -** The first parameter to [sqlite3_exec()] must be an valid and open
   277         -** [database connection].
   278         -**
   279         -** The database connection must not be closed while
   280         -** [sqlite3_exec()] is running.
   281         -**
   282         -** The calling function should use [sqlite3_free()] to free
   283         -** the memory that *errmsg is left pointing at once the error
   284         -** message is no longer needed.
   285         -**
   286         -** The SQL statement text in the 2nd parameter to [sqlite3_exec()]
   287         -** must remain unchanged while [sqlite3_exec()] is running.
   288         -**
   289         -** Requirements:
   290         -** [H12101] [H12102] [H12104] [H12105] [H12107] [H12110] [H12113] [H12116]
   291         -** [H12119] [H12122] [H12125] [H12131] [H12134] [H12137] [H12138]
   292         -*/
   293         -int sqlite3_exec(
          300  +** CAPI3REF: One-Step Query Execution Interface
          301  +**
          302  +** The sqlite3_exec() interface is a convenience wrapper around
          303  +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
          304  +** that allows an application to run multiple statements of SQL
          305  +** without having to use a lot of C code. 
          306  +**
          307  +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
          308  +** semicolon-separate SQL statements passed into its 2nd argument,
          309  +** in the context of the [database connection] passed in as its 1st
          310  +** argument.  ^If the callback function of the 3rd argument to
          311  +** sqlite3_exec() is not NULL, then it is invoked for each result row
          312  +** coming out of the evaluated SQL statements.  ^The 4th argument to
          313  +** to sqlite3_exec() is relayed through to the 1st argument of each
          314  +** callback invocation.  ^If the callback pointer to sqlite3_exec()
          315  +** is NULL, then no callback is ever invoked and result rows are
          316  +** ignored.
          317  +**
          318  +** ^If an error occurs while evaluating the SQL statements passed into
          319  +** sqlite3_exec(), then execution of the current statement stops and
          320  +** subsequent statements are skipped.  ^If the 5th parameter to sqlite3_exec()
          321  +** is not NULL then any error message is written into memory obtained
          322  +** from [sqlite3_malloc()] and passed back through the 5th parameter.
          323  +** To avoid memory leaks, the application should invoke [sqlite3_free()]
          324  +** on error message strings returned through the 5th parameter of
          325  +** of sqlite3_exec() after the error message string is no longer needed.
          326  +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
          327  +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
          328  +** NULL before returning.
          329  +**
          330  +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
          331  +** routine returns SQLITE_ABORT without invoking the callback again and
          332  +** without running any subsequent SQL statements.
          333  +**
          334  +** ^The 2nd argument to the sqlite3_exec() callback function is the
          335  +** number of columns in the result.  ^The 3rd argument to the sqlite3_exec()
          336  +** callback is an array of pointers to strings obtained as if from
          337  +** [sqlite3_column_text()], one for each column.  ^If an element of a
          338  +** result row is NULL then the corresponding string pointer for the
          339  +** sqlite3_exec() callback is a NULL pointer.  ^The 4th argument to the
          340  +** sqlite3_exec() callback is an array of pointers to strings where each
          341  +** entry represents the name of corresponding result column as obtained
          342  +** from [sqlite3_column_name()].
          343  +**
          344  +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer
          345  +** to an empty string, or a pointer that contains only whitespace and/or 
          346  +** SQL comments, then no SQL statements are evaluated and the database
          347  +** is not changed.
          348  +**
          349  +** Restrictions:
          350  +**
          351  +** <ul>
          352  +** <li> The application must insure that the 1st parameter to sqlite3_exec()
          353  +**      is a valid and open [database connection].
          354  +** <li> The application must not close [database connection] specified by
          355  +**      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
          356  +** <li> The application must not modify the SQL statement text passed into
          357  +**      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
          358  +** </ul>
          359  +*/
          360  +SQLITE_API int sqlite3_exec(
   294    361     sqlite3*,                                  /* An open database */
   295    362     const char *sql,                           /* SQL to be evaluated */
   296    363     int (*callback)(void*,int,char**,char**),  /* Callback function */
   297    364     void *,                                    /* 1st argument to callback */
   298    365     char **errmsg                              /* Error msg written here */
   299    366   );
   300    367   
   301    368   /*
   302         -** CAPI3REF: Result Codes {H10210} <S10700>
          369  +** CAPI3REF: Result Codes
   303    370   ** KEYWORDS: SQLITE_OK {error code} {error codes}
   304    371   ** KEYWORDS: {result code} {result codes}
   305    372   **
   306    373   ** Many SQLite functions return an integer result code from the set shown
   307    374   ** here in order to indicates success or failure.
   308    375   **
   309    376   ** New error codes may be added in future versions of SQLite.
................................................................................
   339    406   #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
   340    407   #define SQLITE_NOTADB      26   /* File opened that is not a database file */
   341    408   #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
   342    409   #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
   343    410   /* end-of-error-codes */
   344    411   
   345    412   /*
   346         -** CAPI3REF: Extended Result Codes {H10220} <S10700>
          413  +** CAPI3REF: Extended Result Codes
   347    414   ** KEYWORDS: {extended error code} {extended error codes}
   348    415   ** KEYWORDS: {extended result code} {extended result codes}
   349    416   **
   350    417   ** In its default configuration, SQLite API routines return one of 26 integer
   351    418   ** [SQLITE_OK | result codes].  However, experience has shown that many of
   352    419   ** these result codes are too coarse-grained.  They do not provide as
   353    420   ** much information about problems as programmers might like.  In an effort to
................................................................................
   381    448   #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
   382    449   #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
   383    450   #define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
   384    451   #define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
   385    452   #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED | (1<<8) )
   386    453   
   387    454   /*
   388         -** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>
          455  +** CAPI3REF: Flags For File Open Operations
   389    456   **
   390    457   ** These bit values are intended for use in the
   391    458   ** 3rd parameter to the [sqlite3_open_v2()] interface and
   392    459   ** in the 4th parameter to the xOpen method of the
   393    460   ** [sqlite3_vfs] object.
   394    461   */
   395    462   #define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
   396    463   #define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
   397    464   #define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */
   398    465   #define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
   399    466   #define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
          467  +#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */
   400    468   #define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */
   401    469   #define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */
   402    470   #define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */
   403    471   #define SQLITE_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */
   404    472   #define SQLITE_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */
   405    473   #define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
   406    474   #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */
   407    475   #define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
   408    476   #define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
          477  +#define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
          478  +#define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
   409    479   
   410    480   /*
   411         -** CAPI3REF: Device Characteristics {H10240} <H11120>
          481  +** CAPI3REF: Device Characteristics
   412    482   **
   413    483   ** The xDeviceCapabilities method of the [sqlite3_io_methods]
   414    484   ** object returns an integer which is a vector of the these
   415    485   ** bit values expressing I/O characteristics of the mass storage
   416    486   ** device that holds the file that the [sqlite3_io_methods]
   417    487   ** refers to.
   418    488   **
................................................................................
   436    506   #define SQLITE_IOCAP_ATOMIC16K       0x00000040
   437    507   #define SQLITE_IOCAP_ATOMIC32K       0x00000080
   438    508   #define SQLITE_IOCAP_ATOMIC64K       0x00000100
   439    509   #define SQLITE_IOCAP_SAFE_APPEND     0x00000200
   440    510   #define SQLITE_IOCAP_SEQUENTIAL      0x00000400
   441    511   
   442    512   /*
   443         -** CAPI3REF: File Locking Levels {H10250} <H11120> <H11310>
          513  +** CAPI3REF: File Locking Levels
   444    514   **
   445    515   ** SQLite uses one of these integer values as the second
   446    516   ** argument to calls it makes to the xLock() and xUnlock() methods
   447    517   ** of an [sqlite3_io_methods] object.
   448    518   */
   449    519   #define SQLITE_LOCK_NONE          0
   450    520   #define SQLITE_LOCK_SHARED        1
   451    521   #define SQLITE_LOCK_RESERVED      2
   452    522   #define SQLITE_LOCK_PENDING       3
   453    523   #define SQLITE_LOCK_EXCLUSIVE     4
   454    524   
   455    525   /*
   456         -** CAPI3REF: Synchronization Type Flags {H10260} <H11120>
          526  +** CAPI3REF: Synchronization Type Flags
   457    527   **
   458    528   ** When SQLite invokes the xSync() method of an
   459    529   ** [sqlite3_io_methods] object it uses a combination of
   460    530   ** these integer values as the second argument.
   461    531   **
   462    532   ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
   463    533   ** sync operation only needs to flush data to mass storage.  Inode
................................................................................
   467    537   ** to use Mac OS X style fullsync instead of fsync().
   468    538   */
   469    539   #define SQLITE_SYNC_NORMAL        0x00002
   470    540   #define SQLITE_SYNC_FULL          0x00003
   471    541   #define SQLITE_SYNC_DATAONLY      0x00010
   472    542   
   473    543   /*
   474         -** CAPI3REF: OS Interface Open File Handle {H11110} <S20110>
          544  +** CAPI3REF: OS Interface Open File Handle
   475    545   **
   476         -** An [sqlite3_file] object represents an open file in the OS
   477         -** interface layer.  Individual OS interface implementations will
          546  +** An [sqlite3_file] object represents an open file in the 
          547  +** [sqlite3_vfs | OS interface layer].  Individual OS interface
          548  +** implementations will
   478    549   ** want to subclass this object by appending additional fields
   479    550   ** for their own use.  The pMethods entry is a pointer to an
   480    551   ** [sqlite3_io_methods] object that defines methods for performing
   481    552   ** I/O operations on the open file.
   482    553   */
   483    554   typedef struct sqlite3_file sqlite3_file;
   484    555   struct sqlite3_file {
   485    556     const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
   486    557   };
   487    558   
   488    559   /*
   489         -** CAPI3REF: OS Interface File Virtual Methods Object {H11120} <S20110>
          560  +** CAPI3REF: OS Interface File Virtual Methods Object
   490    561   **
   491    562   ** Every file opened by the [sqlite3_vfs] xOpen method populates an
   492    563   ** [sqlite3_file] object (or, more commonly, a subclass of the
   493    564   ** [sqlite3_file] object) with a pointer to an instance of this object.
   494    565   ** This object defines the methods used to perform various operations
   495    566   ** against the open file represented by the [sqlite3_file] object.
   496    567   **
................................................................................
   587    658     int (*xFileControl)(sqlite3_file*, int op, void *pArg);
   588    659     int (*xSectorSize)(sqlite3_file*);
   589    660     int (*xDeviceCharacteristics)(sqlite3_file*);
   590    661     /* Additional methods may be added in future releases */
   591    662   };
   592    663   
   593    664   /*
   594         -** CAPI3REF: Standard File Control Opcodes {H11310} <S30800>
          665  +** CAPI3REF: Standard File Control Opcodes
   595    666   **
   596    667   ** These integer constants are opcodes for the xFileControl method
   597    668   ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
   598    669   ** interface.
   599    670   **
   600    671   ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
   601    672   ** opcode causes the xFileControl method to write the current state of
................................................................................
   607    678   */
   608    679   #define SQLITE_FCNTL_LOCKSTATE        1
   609    680   #define SQLITE_GET_LOCKPROXYFILE      2
   610    681   #define SQLITE_SET_LOCKPROXYFILE      3
   611    682   #define SQLITE_LAST_ERRNO             4
   612    683   
   613    684   /*
   614         -** CAPI3REF: Mutex Handle {H17110} <S20130>
          685  +** CAPI3REF: Mutex Handle
   615    686   **
   616    687   ** The mutex module within SQLite defines [sqlite3_mutex] to be an
   617    688   ** abstract type for a mutex object.  The SQLite core never looks
   618    689   ** at the internal representation of an [sqlite3_mutex].  It only
   619    690   ** deals with pointers to the [sqlite3_mutex] object.
   620    691   **
   621    692   ** Mutexes are created using [sqlite3_mutex_alloc()].
   622    693   */
   623    694   typedef struct sqlite3_mutex sqlite3_mutex;
   624    695   
   625    696   /*
   626         -** CAPI3REF: OS Interface Object {H11140} <S20100>
          697  +** CAPI3REF: OS Interface Object
   627    698   **
   628    699   ** An instance of the sqlite3_vfs object defines the interface between
   629    700   ** the SQLite core and the underlying operating system.  The "vfs"
   630    701   ** in the name of the object stands for "virtual file system".
   631    702   **
   632    703   ** The value of the iVersion field is initially 1 but may be larger in
   633    704   ** future versions of SQLite.  Additional fields may be appended to this
................................................................................
   773    844     int (*xCurrentTime)(sqlite3_vfs*, double*);
   774    845     int (*xGetLastError)(sqlite3_vfs*, int, char *);
   775    846     /* New fields may be appended in figure versions.  The iVersion
   776    847     ** value will increment whenever this happens. */
   777    848   };
   778    849   
   779    850   /*
   780         -** CAPI3REF: Flags for the xAccess VFS method {H11190} <H11140>
          851  +** CAPI3REF: Flags for the xAccess VFS method
   781    852   **
   782    853   ** These integer constants can be used as the third parameter to
   783         -** the xAccess method of an [sqlite3_vfs] object. {END}  They determine
          854  +** the xAccess method of an [sqlite3_vfs] object.  They determine
   784    855   ** what kind of permissions the xAccess method is looking for.
   785    856   ** With SQLITE_ACCESS_EXISTS, the xAccess method
   786    857   ** simply checks whether the file exists.
   787    858   ** With SQLITE_ACCESS_READWRITE, the xAccess method
   788    859   ** checks whether the file is both readable and writable.
   789    860   ** With SQLITE_ACCESS_READ, the xAccess method
   790    861   ** checks whether the file is readable.
   791    862   */
   792    863   #define SQLITE_ACCESS_EXISTS    0
   793    864   #define SQLITE_ACCESS_READWRITE 1
   794    865   #define SQLITE_ACCESS_READ      2
   795    866   
   796    867   /*
   797         -** CAPI3REF: Initialize The SQLite Library {H10130} <S20000><S30100>
          868  +** CAPI3REF: Initialize The SQLite Library
   798    869   **
   799         -** The sqlite3_initialize() routine initializes the
   800         -** SQLite library.  The sqlite3_shutdown() routine
          870  +** ^The sqlite3_initialize() routine initializes the
          871  +** SQLite library.  ^The sqlite3_shutdown() routine
   801    872   ** deallocates any resources that were allocated by sqlite3_initialize().
          873  +** These routines are designed to aid in process initialization and
          874  +** shutdown on embedded systems.  Workstation applications using
          875  +** SQLite normally do not need to invoke either of these routines.
   802    876   **
   803    877   ** A call to sqlite3_initialize() is an "effective" call if it is
   804    878   ** the first time sqlite3_initialize() is invoked during the lifetime of
   805    879   ** the process, or if it is the first time sqlite3_initialize() is invoked
   806         -** following a call to sqlite3_shutdown().  Only an effective call
          880  +** following a call to sqlite3_shutdown().  ^(Only an effective call
   807    881   ** of sqlite3_initialize() does any initialization.  All other calls
   808         -** are harmless no-ops.
          882  +** are harmless no-ops.)^
   809    883   **
   810    884   ** A call to sqlite3_shutdown() is an "effective" call if it is the first
   811         -** call to sqlite3_shutdown() since the last sqlite3_initialize().  Only
          885  +** call to sqlite3_shutdown() since the last sqlite3_initialize().  ^(Only
   812    886   ** an effective call to sqlite3_shutdown() does any deinitialization.
   813         -** All other calls to sqlite3_shutdown() are harmless no-ops.
          887  +** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
   814    888   **
   815         -** Among other things, sqlite3_initialize() shall invoke
   816         -** sqlite3_os_init().  Similarly, sqlite3_shutdown()
   817         -** shall invoke sqlite3_os_end().
          889  +** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()
          890  +** is not.  The sqlite3_shutdown() interface must only be called from a
          891  +** single thread.  All open [database connections] must be closed and all
          892  +** other SQLite resources must be deallocated prior to invoking
          893  +** sqlite3_shutdown().
   818    894   **
   819         -** The sqlite3_initialize() routine returns [SQLITE_OK] on success.
   820         -** If for some reason, sqlite3_initialize() is unable to initialize
          895  +** Among other things, ^sqlite3_initialize() will invoke
          896  +** sqlite3_os_init().  Similarly, ^sqlite3_shutdown()
          897  +** will invoke sqlite3_os_end().
          898  +**
          899  +** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
          900  +** ^If for some reason, sqlite3_initialize() is unable to initialize
   821    901   ** the library (perhaps it is unable to allocate a needed resource such
   822    902   ** as a mutex) it returns an [error code] other than [SQLITE_OK].
   823    903   **
   824         -** The sqlite3_initialize() routine is called internally by many other
          904  +** ^The sqlite3_initialize() routine is called internally by many other
   825    905   ** SQLite interfaces so that an application usually does not need to
   826    906   ** invoke sqlite3_initialize() directly.  For example, [sqlite3_open()]
   827    907   ** calls sqlite3_initialize() so the SQLite library will be automatically
   828    908   ** initialized when [sqlite3_open()] is called if it has not be initialized
   829         -** already.  However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
          909  +** already.  ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
   830    910   ** compile-time option, then the automatic calls to sqlite3_initialize()
   831    911   ** are omitted and the application must call sqlite3_initialize() directly
   832    912   ** prior to using any other SQLite interface.  For maximum portability,
   833    913   ** it is recommended that applications always invoke sqlite3_initialize()
   834    914   ** directly prior to using any other SQLite interface.  Future releases
   835    915   ** of SQLite may require this.  In other words, the behavior exhibited
   836    916   ** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the
................................................................................
   846    926   **
   847    927   ** The application should never invoke either sqlite3_os_init()
   848    928   ** or sqlite3_os_end() directly.  The application should only invoke
   849    929   ** sqlite3_initialize() and sqlite3_shutdown().  The sqlite3_os_init()
   850    930   ** interface is called automatically by sqlite3_initialize() and
   851    931   ** sqlite3_os_end() is called by sqlite3_shutdown().  Appropriate
   852    932   ** implementations for sqlite3_os_init() and sqlite3_os_end()
   853         -** are built into SQLite when it is compiled for unix, windows, or os/2.
   854         -** When built for other platforms (using the [SQLITE_OS_OTHER=1] compile-time
          933  +** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
          934  +** When [custom builds | built for other platforms]
          935  +** (using the [SQLITE_OS_OTHER=1] compile-time
   855    936   ** option) the application must supply a suitable implementation for
   856    937   ** sqlite3_os_init() and sqlite3_os_end().  An application-supplied
   857    938   ** implementation of sqlite3_os_init() or sqlite3_os_end()
   858    939   ** must return [SQLITE_OK] on success and some other [error code] upon
   859    940   ** failure.
   860    941   */
   861         -int sqlite3_initialize(void);
   862         -int sqlite3_shutdown(void);
   863         -int sqlite3_os_init(void);
   864         -int sqlite3_os_end(void);
          942  +SQLITE_API int sqlite3_initialize(void);
          943  +SQLITE_API int sqlite3_shutdown(void);
          944  +SQLITE_API int sqlite3_os_init(void);
          945  +SQLITE_API int sqlite3_os_end(void);
   865    946   
   866    947   /*
   867         -** CAPI3REF: Configuring The SQLite Library {H14100} <S20000><S30200>
   868         -** EXPERIMENTAL
          948  +** CAPI3REF: Configuring The SQLite Library
   869    949   **
   870    950   ** The sqlite3_config() interface is used to make global configuration
   871    951   ** changes to SQLite in order to tune SQLite to the specific needs of
   872    952   ** the application.  The default configuration is recommended for most
   873    953   ** applications and so this routine is usually not necessary.  It is
   874    954   ** provided to support rare applications with unusual needs.
   875    955   **
   876    956   ** The sqlite3_config() interface is not threadsafe.  The application
   877    957   ** must insure that no other SQLite interfaces are invoked by other
   878    958   ** threads while sqlite3_config() is running.  Furthermore, sqlite3_config()
   879    959   ** may only be invoked prior to library initialization using
   880    960   ** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
   881         -** Note, however, that sqlite3_config() can be called as part of the
          961  +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
          962  +** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
          963  +** Note, however, that ^sqlite3_config() can be called as part of the
   882    964   ** implementation of an application-defined [sqlite3_os_init()].
   883    965   **
   884    966   ** The first argument to sqlite3_config() is an integer
   885    967   ** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines
   886    968   ** what property of SQLite is to be configured.  Subsequent arguments
   887    969   ** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option]
   888    970   ** in the first argument.
   889    971   **
   890         -** When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
   891         -** If the option is unknown or SQLite is unable to set the option
          972  +** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
          973  +** ^If the option is unknown or SQLite is unable to set the option
   892    974   ** then this routine returns a non-zero [error code].
   893         -**
   894         -** Requirements:
   895         -** [H14103] [H14106] [H14120] [H14123] [H14126] [H14129] [H14132] [H14135]
   896         -** [H14138] [H14141] [H14144] [H14147] [H14150] [H14153] [H14156] [H14159]
   897         -** [H14162] [H14165] [H14168]
   898    975   */
   899         -SQLITE_EXPERIMENTAL int sqlite3_config(int, ...);
          976  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_config(int, ...);
   900    977   
   901    978   /*
   902         -** CAPI3REF: Configure database connections  {H14200} <S20000>
          979  +** CAPI3REF: Configure database connections
   903    980   ** EXPERIMENTAL
   904    981   **
   905    982   ** The sqlite3_db_config() interface is used to make configuration
   906    983   ** changes to a [database connection].  The interface is similar to
   907    984   ** [sqlite3_config()] except that the changes apply to a single
   908    985   ** [database connection] (specified in the first argument).  The
   909         -** sqlite3_db_config() interface can only be used immediately after
          986  +** sqlite3_db_config() interface should only be used immediately after
   910    987   ** the database connection is created using [sqlite3_open()],
   911    988   ** [sqlite3_open16()], or [sqlite3_open_v2()].  
   912    989   **
   913    990   ** The second argument to sqlite3_db_config(D,V,...)  is the
   914    991   ** configuration verb - an integer code that indicates what
   915    992   ** aspect of the [database connection] is being configured.
   916    993   ** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE].
   917    994   ** New verbs are likely to be added in future releases of SQLite.
   918    995   ** Additional arguments depend on the verb.
   919    996   **
   920         -** Requirements:
   921         -** [H14203] [H14206] [H14209] [H14212] [H14215]
          997  +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
          998  +** the call is considered successful.
   922    999   */
   923         -SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
         1000  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);
   924   1001   
   925   1002   /*
   926         -** CAPI3REF: Memory Allocation Routines {H10155} <S20120>
         1003  +** CAPI3REF: Memory Allocation Routines
   927   1004   ** EXPERIMENTAL
   928   1005   **
   929   1006   ** An instance of this object defines the interface between SQLite
   930   1007   ** and low-level memory allocation routines.
   931   1008   **
   932   1009   ** This object is used in only one place in the SQLite interface.
   933   1010   ** A pointer to an instance of this object is the argument to
   934   1011   ** [sqlite3_config()] when the configuration option is
   935         -** [SQLITE_CONFIG_MALLOC].  By creating an instance of this object
   936         -** and passing it to [sqlite3_config()] during configuration, an
   937         -** application can specify an alternative memory allocation subsystem
   938         -** for SQLite to use for all of its dynamic memory needs.
         1012  +** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].  
         1013  +** By creating an instance of this object
         1014  +** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
         1015  +** during configuration, an application can specify an alternative
         1016  +** memory allocation subsystem for SQLite to use for all of its
         1017  +** dynamic memory needs.
   939   1018   **
   940         -** Note that SQLite comes with a built-in memory allocator that is
   941         -** perfectly adequate for the overwhelming majority of applications
         1019  +** Note that SQLite comes with several [built-in memory allocators]
         1020  +** that are perfectly adequate for the overwhelming majority of applications
   942   1021   ** and that this object is only useful to a tiny minority of applications
   943   1022   ** with specialized memory allocation requirements.  This object is
   944   1023   ** also used during testing of SQLite in order to specify an alternative
   945   1024   ** memory allocator that simulates memory out-of-memory conditions in
   946   1025   ** order to verify that SQLite recovers gracefully from such
   947   1026   ** conditions.
   948   1027   **
   949         -** The xMalloc, xFree, and xRealloc methods must work like the
   950         -** malloc(), free(), and realloc() functions from the standard library.
         1028  +** The xMalloc and xFree methods must work like the
         1029  +** malloc() and free() functions from the standard C library.
         1030  +** The xRealloc method must work like realloc() from the standard C library
         1031  +** with the exception that if the second argument to xRealloc is zero,
         1032  +** xRealloc must be a no-op - it must not perform any allocation or
         1033  +** deallocation.  ^SQLite guarantees that the second argument to
         1034  +** xRealloc is always a value returned by a prior call to xRoundup.
         1035  +** And so in cases where xRoundup always returns a positive number,
         1036  +** xRealloc can perform exactly as the standard library realloc() and
         1037  +** still be in compliance with this specification.
   951   1038   **
   952   1039   ** xSize should return the allocated size of a memory allocation
   953   1040   ** previously obtained from xMalloc or xRealloc.  The allocated size
   954   1041   ** is always at least as big as the requested size but may be larger.
   955   1042   **
   956   1043   ** The xRoundup method returns what would be the allocated size of
   957   1044   ** a memory allocation given a particular requested size.  Most memory
   958   1045   ** allocators round up memory allocations at least to the next multiple
   959   1046   ** of 8.  Some allocators round up to a larger multiple or to a power of 2.
         1047  +** Every memory allocation request coming in through [sqlite3_malloc()]
         1048  +** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0, 
         1049  +** that causes the corresponding memory allocation to fail.
   960   1050   **
   961   1051   ** The xInit method initializes the memory allocator.  (For example,
   962   1052   ** it might allocate any require mutexes or initialize internal data
   963   1053   ** structures.  The xShutdown method is invoked (indirectly) by
   964   1054   ** [sqlite3_shutdown()] and should deallocate any resources acquired
   965   1055   ** by xInit.  The pAppData pointer is used as the only parameter to
   966   1056   ** xInit and xShutdown.
         1057  +**
         1058  +** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
         1059  +** the xInit method, so the xInit method need not be threadsafe.  The
         1060  +** xShutdown method is only called from [sqlite3_shutdown()] so it does
         1061  +** not need to be threadsafe either.  For all other methods, SQLite
         1062  +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
         1063  +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
         1064  +** it is by default) and so the methods are automatically serialized.
         1065  +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
         1066  +** methods must be threadsafe or else make their own arrangements for
         1067  +** serialization.
         1068  +**
         1069  +** SQLite will never invoke xInit() more than once without an intervening
         1070  +** call to xShutdown().
   967   1071   */
   968   1072   typedef struct sqlite3_mem_methods sqlite3_mem_methods;
   969   1073   struct sqlite3_mem_methods {
   970   1074     void *(*xMalloc)(int);         /* Memory allocation function */
   971   1075     void (*xFree)(void*);          /* Free a prior allocation */
   972   1076     void *(*xRealloc)(void*,int);  /* Resize an allocation */
   973   1077     int (*xSize)(void*);           /* Return the size of an allocation */
................................................................................
   974   1078     int (*xRoundup)(int);          /* Round up request size to allocation size */
   975   1079     int (*xInit)(void*);           /* Initialize the memory allocator */
   976   1080     void (*xShutdown)(void*);      /* Deinitialize the memory allocator */
   977   1081     void *pAppData;                /* Argument to xInit() and xShutdown() */
   978   1082   };
   979   1083   
   980   1084   /*
   981         -** CAPI3REF: Configuration Options {H10160} <S20000>
         1085  +** CAPI3REF: Configuration Options
   982   1086   ** EXPERIMENTAL
   983   1087   **
   984   1088   ** These constants are the available integer configuration options that
   985   1089   ** can be passed as the first argument to the [sqlite3_config()] interface.
   986   1090   **
   987   1091   ** New configuration options may be added in future releases of SQLite.
   988   1092   ** Existing configuration options might be discontinued.  Applications
................................................................................
   989   1093   ** should check the return code from [sqlite3_config()] to make sure that
   990   1094   ** the call worked.  The [sqlite3_config()] interface will return a
   991   1095   ** non-zero [error code] if a discontinued or unsupported configuration option
   992   1096   ** is invoked.
   993   1097   **
   994   1098   ** <dl>
   995   1099   ** <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
   996         -** <dd>There are no arguments to this option.  This option disables
         1100  +** <dd>There are no arguments to this option.  ^This option sets the
         1101  +** [threading mode] to Single-thread.  In other words, it disables
   997   1102   ** all mutexing and puts SQLite into a mode where it can only be used
   998         -** by a single thread.</dd>
         1103  +** by a single thread.   ^If SQLite is compiled with
         1104  +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
         1105  +** it is not possible to change the [threading mode] from its default
         1106  +** value of Single-thread and so [sqlite3_config()] will return 
         1107  +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD
         1108  +** configuration option.</dd>
   999   1109   **
  1000   1110   ** <dt>SQLITE_CONFIG_MULTITHREAD</dt>
  1001         -** <dd>There are no arguments to this option.  This option disables
         1111  +** <dd>There are no arguments to this option.  ^This option sets the
         1112  +** [threading mode] to Multi-thread.  In other words, it disables
  1002   1113   ** mutexing on [database connection] and [prepared statement] objects.
  1003   1114   ** The application is responsible for serializing access to
  1004   1115   ** [database connections] and [prepared statements].  But other mutexes
  1005   1116   ** are enabled so that SQLite will be safe to use in a multi-threaded
  1006   1117   ** environment as long as no two threads attempt to use the same
  1007         -** [database connection] at the same time.  See the [threading mode]
  1008         -** documentation for additional information.</dd>
         1118  +** [database connection] at the same time.  ^If SQLite is compiled with
         1119  +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
         1120  +** it is not possible to set the Multi-thread [threading mode] and
         1121  +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
         1122  +** SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
  1009   1123   **
  1010   1124   ** <dt>SQLITE_CONFIG_SERIALIZED</dt>
  1011         -** <dd>There are no arguments to this option.  This option enables
         1125  +** <dd>There are no arguments to this option.  ^This option sets the
         1126  +** [threading mode] to Serialized. In other words, this option enables
  1012   1127   ** all mutexes including the recursive
  1013   1128   ** mutexes on [database connection] and [prepared statement] objects.
  1014   1129   ** In this mode (which is the default when SQLite is compiled with
  1015   1130   ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
  1016   1131   ** to [database connections] and [prepared statements] so that the
  1017   1132   ** application is free to use the same [database connection] or the
  1018   1133   ** same [prepared statement] in different threads at the same time.
  1019         -** See the [threading mode] documentation for additional information.</dd>
         1134  +** ^If SQLite is compiled with
         1135  +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
         1136  +** it is not possible to set the Serialized [threading mode] and
         1137  +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
         1138  +** SQLITE_CONFIG_SERIALIZED configuration option.</dd>
  1020   1139   **
  1021   1140   ** <dt>SQLITE_CONFIG_MALLOC</dt>
  1022         -** <dd>This option takes a single argument which is a pointer to an
         1141  +** <dd> ^(This option takes a single argument which is a pointer to an
  1023   1142   ** instance of the [sqlite3_mem_methods] structure.  The argument specifies
  1024   1143   ** alternative low-level memory allocation routines to be used in place of
  1025         -** the memory allocation routines built into SQLite.</dd>
         1144  +** the memory allocation routines built into SQLite.)^ ^SQLite makes
         1145  +** its own private copy of the content of the [sqlite3_mem_methods] structure
         1146  +** before the [sqlite3_config()] call returns.</dd>
  1026   1147   **
  1027   1148   ** <dt>SQLITE_CONFIG_GETMALLOC</dt>
  1028         -** <dd>This option takes a single argument which is a pointer to an
         1149  +** <dd> ^(This option takes a single argument which is a pointer to an
  1029   1150   ** instance of the [sqlite3_mem_methods] structure.  The [sqlite3_mem_methods]
  1030         -** structure is filled with the currently defined memory allocation routines.
         1151  +** structure is filled with the currently defined memory allocation routines.)^
  1031   1152   ** This option can be used to overload the default memory allocation
  1032   1153   ** routines with a wrapper that simulations memory allocation failure or
  1033         -** tracks memory usage, for example.</dd>
         1154  +** tracks memory usage, for example. </dd>
  1034   1155   **
  1035   1156   ** <dt>SQLITE_CONFIG_MEMSTATUS</dt>
  1036         -** <dd>This option takes single argument of type int, interpreted as a 
         1157  +** <dd> ^This option takes single argument of type int, interpreted as a 
  1037   1158   ** boolean, which enables or disables the collection of memory allocation 
  1038         -** statistics. When disabled, the following SQLite interfaces become 
  1039         -** non-operational:
         1159  +** statistics. ^(When memory allocation statistics are disabled, the 
         1160  +** following SQLite interfaces become non-operational:
  1040   1161   **   <ul>
  1041   1162   **   <li> [sqlite3_memory_used()]
  1042   1163   **   <li> [sqlite3_memory_highwater()]
  1043   1164   **   <li> [sqlite3_soft_heap_limit()]
  1044   1165   **   <li> [sqlite3_status()]
  1045         -**   </ul>
         1166  +**   </ul>)^
         1167  +** ^Memory allocation statistics are enabled by default unless SQLite is
         1168  +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
         1169  +** allocation statistics are disabled by default.
  1046   1170   ** </dd>
  1047   1171   **
  1048   1172   ** <dt>SQLITE_CONFIG_SCRATCH</dt>
  1049         -** <dd>This option specifies a static memory buffer that SQLite can use for
         1173  +** <dd> ^This option specifies a static memory buffer that SQLite can use for
  1050   1174   ** scratch memory.  There are three arguments:  A pointer an 8-byte
  1051   1175   ** aligned memory buffer from which the scrach allocations will be
  1052   1176   ** drawn, the size of each scratch allocation (sz),
  1053   1177   ** and the maximum number of scratch allocations (N).  The sz
  1054   1178   ** argument must be a multiple of 16. The sz parameter should be a few bytes
  1055   1179   ** larger than the actual scratch space required due to internal overhead.
  1056         -** The first argument should pointer to an 8-byte aligned buffer
         1180  +** The first argument must be a pointer to an 8-byte aligned buffer
  1057   1181   ** of at least sz*N bytes of memory.
  1058         -** SQLite will use no more than one scratch buffer at once per thread, so
  1059         -** N should be set to the expected maximum number of threads.  The sz
  1060         -** parameter should be 6 times the size of the largest database page size.
  1061         -** Scratch buffers are used as part of the btree balance operation.  If
  1062         -** The btree balancer needs additional memory beyond what is provided by
  1063         -** scratch buffers or if no scratch buffer space is specified, then SQLite
  1064         -** goes to [sqlite3_malloc()] to obtain the memory it needs.</dd>
         1182  +** ^SQLite will use no more than one scratch buffer per thread.  So
         1183  +** N should be set to the expected maximum number of threads.  ^SQLite will
         1184  +** never require a scratch buffer that is more than 6 times the database
         1185  +** page size. ^If SQLite needs needs additional scratch memory beyond 
         1186  +** what is provided by this configuration option, then 
         1187  +** [sqlite3_malloc()] will be used to obtain the memory needed.</dd>
  1065   1188   **
  1066   1189   ** <dt>SQLITE_CONFIG_PAGECACHE</dt>
  1067         -** <dd>This option specifies a static memory buffer that SQLite can use for
         1190  +** <dd> ^This option specifies a static memory buffer that SQLite can use for
  1068   1191   ** the database page cache with the default page cache implemenation.  
  1069   1192   ** This configuration should not be used if an application-define page
  1070   1193   ** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option.
  1071   1194   ** There are three arguments to this option: A pointer to 8-byte aligned
  1072   1195   ** memory, the size of each page buffer (sz), and the number of pages (N).
  1073   1196   ** The sz argument should be the size of the largest database page
  1074   1197   ** (a power of two between 512 and 32768) plus a little extra for each
  1075         -** page header.  The page header size is 20 to 40 bytes depending on
  1076         -** the host architecture.  It is harmless, apart from the wasted memory,
         1198  +** page header.  ^The page header size is 20 to 40 bytes depending on
         1199  +** the host architecture.  ^It is harmless, apart from the wasted memory,
  1077   1200   ** to make sz a little too large.  The first
  1078   1201   ** argument should point to an allocation of at least sz*N bytes of memory.
  1079         -** SQLite will use the memory provided by the first argument to satisfy its
  1080         -** memory needs for the first N pages that it adds to cache.  If additional
         1202  +** ^SQLite will use the memory provided by the first argument to satisfy its
         1203  +** memory needs for the first N pages that it adds to cache.  ^If additional
  1081   1204   ** page cache memory is needed beyond what is provided by this option, then
  1082   1205   ** SQLite goes to [sqlite3_malloc()] for the additional storage space.
  1083         -** The implementation might use one or more of the N buffers to hold 
         1206  +** ^The implementation might use one or more of the N buffers to hold 
  1084   1207   ** memory accounting information. The pointer in the first argument must
  1085   1208   ** be aligned to an 8-byte boundary or subsequent behavior of SQLite
  1086   1209   ** will be undefined.</dd>
  1087   1210   **
  1088   1211   ** <dt>SQLITE_CONFIG_HEAP</dt>
  1089         -** <dd>This option specifies a static memory buffer that SQLite will use
         1212  +** <dd> ^This option specifies a static memory buffer that SQLite will use
  1090   1213   ** for all of its dynamic memory allocation needs beyond those provided
  1091   1214   ** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].
  1092   1215   ** There are three arguments: An 8-byte aligned pointer to the memory,
  1093   1216   ** the number of bytes in the memory buffer, and the minimum allocation size.
  1094         -** If the first pointer (the memory pointer) is NULL, then SQLite reverts
         1217  +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
  1095   1218   ** to using its default memory allocator (the system malloc() implementation),
  1096         -** undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  If the
         1219  +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  ^If the
  1097   1220   ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
  1098   1221   ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
  1099   1222   ** allocator is engaged to handle all of SQLites memory allocation needs.
  1100   1223   ** The first pointer (the memory pointer) must be aligned to an 8-byte
  1101   1224   ** boundary or subsequent behavior of SQLite will be undefined.</dd>
  1102   1225   **
  1103   1226   ** <dt>SQLITE_CONFIG_MUTEX</dt>
  1104         -** <dd>This option takes a single argument which is a pointer to an
         1227  +** <dd> ^(This option takes a single argument which is a pointer to an
  1105   1228   ** instance of the [sqlite3_mutex_methods] structure.  The argument specifies
  1106   1229   ** alternative low-level mutex routines to be used in place
  1107         -** the mutex routines built into SQLite.</dd>
         1230  +** the mutex routines built into SQLite.)^  ^SQLite makes a copy of the
         1231  +** content of the [sqlite3_mutex_methods] structure before the call to
         1232  +** [sqlite3_config()] returns. ^If SQLite is compiled with
         1233  +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
         1234  +** the entire mutexing subsystem is omitted from the build and hence calls to
         1235  +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
         1236  +** return [SQLITE_ERROR].</dd>
  1108   1237   **
  1109   1238   ** <dt>SQLITE_CONFIG_GETMUTEX</dt>
  1110         -** <dd>This option takes a single argument which is a pointer to an
         1239  +** <dd> ^(This option takes a single argument which is a pointer to an
  1111   1240   ** instance of the [sqlite3_mutex_methods] structure.  The
  1112   1241   ** [sqlite3_mutex_methods]
  1113         -** structure is filled with the currently defined mutex routines.
         1242  +** structure is filled with the currently defined mutex routines.)^
  1114   1243   ** This option can be used to overload the default mutex allocation
  1115   1244   ** routines with a wrapper used to track mutex usage for performance
  1116         -** profiling or testing, for example.</dd>
         1245  +** profiling or testing, for example.   ^If SQLite is compiled with
         1246  +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
         1247  +** the entire mutexing subsystem is omitted from the build and hence calls to
         1248  +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
         1249  +** return [SQLITE_ERROR].</dd>
  1117   1250   **
  1118   1251   ** <dt>SQLITE_CONFIG_LOOKASIDE</dt>
  1119         -** <dd>This option takes two arguments that determine the default
  1120         -** memory allcation lookaside optimization.  The first argument is the
         1252  +** <dd> ^(This option takes two arguments that determine the default
         1253  +** memory allocation for the lookaside memory allocator on each
         1254  +** [database connection].  The first argument is the
  1121   1255   ** size of each lookaside buffer slot and the second is the number of
  1122         -** slots allocated to each database connection.</dd>
         1256  +** slots allocated to each database connection.)^  ^(This option sets the
         1257  +** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
         1258  +** verb to [sqlite3_db_config()] can be used to change the lookaside
         1259  +** configuration on individual connections.)^ </dd>
  1123   1260   **
  1124   1261   ** <dt>SQLITE_CONFIG_PCACHE</dt>
  1125         -** <dd>This option takes a single argument which is a pointer to
         1262  +** <dd> ^(This option takes a single argument which is a pointer to
  1126   1263   ** an [sqlite3_pcache_methods] object.  This object specifies the interface
  1127         -** to a custom page cache implementation.  SQLite makes a copy of the
         1264  +** to a custom page cache implementation.)^  ^SQLite makes a copy of the
  1128   1265   ** object and uses it for page cache memory allocations.</dd>
  1129   1266   **
  1130   1267   ** <dt>SQLITE_CONFIG_GETPCACHE</dt>
  1131         -** <dd>This option takes a single argument which is a pointer to an
         1268  +** <dd> ^(This option takes a single argument which is a pointer to an
  1132   1269   ** [sqlite3_pcache_methods] object.  SQLite copies of the current
  1133         -** page cache implementation into that object.</dd>
         1270  +** page cache implementation into that object.)^ </dd>
  1134   1271   **
  1135   1272   ** </dl>
  1136   1273   */
  1137   1274   #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
  1138   1275   #define SQLITE_CONFIG_MULTITHREAD   2  /* nil */
  1139   1276   #define SQLITE_CONFIG_SERIALIZED    3  /* nil */
  1140   1277   #define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */
................................................................................
  1145   1282   #define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */
  1146   1283   #define SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */
  1147   1284   #define SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */
  1148   1285   /* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ 
  1149   1286   #define SQLITE_CONFIG_LOOKASIDE    13  /* int int */
  1150   1287   #define SQLITE_CONFIG_PCACHE       14  /* sqlite3_pcache_methods* */
  1151   1288   #define SQLITE_CONFIG_GETPCACHE    15  /* sqlite3_pcache_methods* */
         1289  +#define SQLITE_CONFIG_LOG          16  /* xFunc, void* */
  1152   1290   
  1153   1291   /*
  1154         -** CAPI3REF: Configuration Options {H10170} <S20000>
         1292  +** CAPI3REF: Configuration Options
  1155   1293   ** EXPERIMENTAL
  1156   1294   **
  1157   1295   ** These constants are the available integer configuration options that
  1158   1296   ** can be passed as the second argument to the [sqlite3_db_config()] interface.
  1159   1297   **
  1160   1298   ** New configuration options may be added in future releases of SQLite.
  1161   1299   ** Existing configuration options might be discontinued.  Applications
  1162   1300   ** should check the return code from [sqlite3_db_config()] to make sure that
  1163         -** the call worked.  The [sqlite3_db_config()] interface will return a
         1301  +** the call worked.  ^The [sqlite3_db_config()] interface will return a
  1164   1302   ** non-zero [error code] if a discontinued or unsupported configuration option
  1165   1303   ** is invoked.
  1166   1304   **
  1167   1305   ** <dl>
  1168   1306   ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
  1169         -** <dd>This option takes three additional arguments that determine the 
         1307  +** <dd> ^This option takes three additional arguments that determine the 
  1170   1308   ** [lookaside memory allocator] configuration for the [database connection].
  1171         -** The first argument (the third parameter to [sqlite3_db_config()] is a
  1172         -** pointer to an 8-byte aligned memory buffer to use for lookaside memory.
  1173         -** The first argument may be NULL in which case SQLite will allocate the
  1174         -** lookaside buffer itself using [sqlite3_malloc()].  The second argument is the
  1175         -** size of each lookaside buffer slot and the third argument is the number of
         1309  +** ^The first argument (the third parameter to [sqlite3_db_config()] is a
         1310  +** pointer to an memory buffer to use for lookaside memory.
         1311  +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
         1312  +** may be NULL in which case SQLite will allocate the
         1313  +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
         1314  +** size of each lookaside buffer slot.  ^The third argument is the number of
  1176   1315   ** slots.  The size of the buffer in the first argument must be greater than
  1177         -** or equal to the product of the second and third arguments.</dd>
         1316  +** or equal to the product of the second and third arguments.  The buffer
         1317  +** must be aligned to an 8-byte boundary.  ^If the second argument to
         1318  +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
         1319  +** rounded down to the next smaller
         1320  +** multiple of 8.  See also: [SQLITE_CONFIG_LOOKASIDE]</dd>
  1178   1321   **
  1179   1322   ** </dl>
  1180   1323   */
  1181   1324   #define SQLITE_DBCONFIG_LOOKASIDE    1001  /* void* int int */
  1182   1325   
  1183   1326   
  1184   1327   /*
  1185         -** CAPI3REF: Enable Or Disable Extended Result Codes {H12200} <S10700>
         1328  +** CAPI3REF: Enable Or Disable Extended Result Codes
  1186   1329   **
  1187         -** The sqlite3_extended_result_codes() routine enables or disables the
  1188         -** [extended result codes] feature of SQLite. The extended result
  1189         -** codes are disabled by default for historical compatibility considerations.
  1190         -**
  1191         -** Requirements:
  1192         -** [H12201] [H12202]
         1330  +** ^The sqlite3_extended_result_codes() routine enables or disables the
         1331  +** [extended result codes] feature of SQLite. ^The extended result
         1332  +** codes are disabled by default for historical compatibility.
  1193   1333   */
  1194         -int sqlite3_extended_result_codes(sqlite3*, int onoff);
         1334  +SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
  1195   1335   
  1196   1336   /*
  1197         -** CAPI3REF: Last Insert Rowid {H12220} <S10700>
         1337  +** CAPI3REF: Last Insert Rowid
  1198   1338   **
  1199         -** Each entry in an SQLite table has a unique 64-bit signed
  1200         -** integer key called the [ROWID | "rowid"]. The rowid is always available
         1339  +** ^Each entry in an SQLite table has a unique 64-bit signed
         1340  +** integer key called the [ROWID | "rowid"]. ^The rowid is always available
  1201   1341   ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
  1202         -** names are not also used by explicitly declared columns. If
         1342  +** names are not also used by explicitly declared columns. ^If
  1203   1343   ** the table has a column of type [INTEGER PRIMARY KEY] then that column
  1204   1344   ** is another alias for the rowid.
  1205   1345   **
  1206         -** This routine returns the [rowid] of the most recent
         1346  +** ^This routine returns the [rowid] of the most recent
  1207   1347   ** successful [INSERT] into the database from the [database connection]
  1208         -** in the first argument.  If no successful [INSERT]s
         1348  +** in the first argument.  ^If no successful [INSERT]s
  1209   1349   ** have ever occurred on that database connection, zero is returned.
  1210   1350   **
  1211         -** If an [INSERT] occurs within a trigger, then the [rowid] of the inserted
         1351  +** ^(If an [INSERT] occurs within a trigger, then the [rowid] of the inserted
  1212   1352   ** row is returned by this routine as long as the trigger is running.
  1213   1353   ** But once the trigger terminates, the value returned by this routine
  1214         -** reverts to the last value inserted before the trigger fired.
         1354  +** reverts to the last value inserted before the trigger fired.)^
  1215   1355   **
  1216         -** An [INSERT] that fails due to a constraint violation is not a
         1356  +** ^An [INSERT] that fails due to a constraint violation is not a
  1217   1357   ** successful [INSERT] and does not change the value returned by this
  1218         -** routine.  Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
         1358  +** routine.  ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
  1219   1359   ** and INSERT OR ABORT make no changes to the return value of this
  1220         -** routine when their insertion fails.  When INSERT OR REPLACE
         1360  +** routine when their insertion fails.  ^(When INSERT OR REPLACE
  1221   1361   ** encounters a constraint violation, it does not fail.  The
  1222   1362   ** INSERT continues to completion after deleting rows that caused
  1223   1363   ** the constraint problem so INSERT OR REPLACE will always change
  1224         -** the return value of this interface.
         1364  +** the return value of this interface.)^
  1225   1365   **
  1226         -** For the purposes of this routine, an [INSERT] is considered to
         1366  +** ^For the purposes of this routine, an [INSERT] is considered to
  1227   1367   ** be successful even if it is subsequently rolled back.
  1228   1368   **
  1229         -** Requirements:
  1230         -** [H12221] [H12223]
         1369  +** This function is accessible to SQL statements via the
         1370  +** [last_insert_rowid() SQL function].
  1231   1371   **
  1232   1372   ** If a separate thread performs a new [INSERT] on the same
  1233   1373   ** database connection while the [sqlite3_last_insert_rowid()]
  1234   1374   ** function is running and thus changes the last insert [rowid],
  1235   1375   ** then the value returned by [sqlite3_last_insert_rowid()] is
  1236   1376   ** unpredictable and might not equal either the old or the new
  1237   1377   ** last insert [rowid].
  1238   1378   */
  1239         -sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
         1379  +SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
  1240   1380   
  1241   1381   /*
  1242         -** CAPI3REF: Count The Number Of Rows Modified {H12240} <S10600>
         1382  +** CAPI3REF: Count The Number Of Rows Modified
  1243   1383   **
  1244         -** This function returns the number of database rows that were changed
         1384  +** ^This function returns the number of database rows that were changed
  1245   1385   ** or inserted or deleted by the most recently completed SQL statement
  1246   1386   ** on the [database connection] specified by the first parameter.
  1247         -** Only changes that are directly specified by the [INSERT], [UPDATE],
         1387  +** ^(Only changes that are directly specified by the [INSERT], [UPDATE],
  1248   1388   ** or [DELETE] statement are counted.  Auxiliary changes caused by
  1249         -** triggers are not counted. Use the [sqlite3_total_changes()] function
  1250         -** to find the total number of changes including changes caused by triggers.
         1389  +** triggers or [foreign key actions] are not counted.)^ Use the
         1390  +** [sqlite3_total_changes()] function to find the total number of changes
         1391  +** including changes caused by triggers and foreign key actions.
  1251   1392   **
  1252         -** Changes to a view that are simulated by an [INSTEAD OF trigger]
         1393  +** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
  1253   1394   ** are not counted.  Only real table changes are counted.
  1254   1395   **
  1255         -** A "row change" is a change to a single row of a single table
         1396  +** ^(A "row change" is a change to a single row of a single table
  1256   1397   ** caused by an INSERT, DELETE, or UPDATE statement.  Rows that
  1257   1398   ** are changed as side effects of [REPLACE] constraint resolution,
  1258   1399   ** rollback, ABORT processing, [DROP TABLE], or by any other
  1259         -** mechanisms do not count as direct row changes.
         1400  +** mechanisms do not count as direct row changes.)^
  1260   1401   **
  1261   1402   ** A "trigger context" is a scope of execution that begins and
  1262   1403   ** ends with the script of a [CREATE TRIGGER | trigger]. 
  1263   1404   ** Most SQL statements are
  1264   1405   ** evaluated outside of any trigger.  This is the "top level"
  1265   1406   ** trigger context.  If a trigger fires from the top level, a
  1266   1407   ** new trigger context is entered for the duration of that one
  1267   1408   ** trigger.  Subtriggers create subcontexts for their duration.
  1268   1409   **
  1269         -** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
         1410  +** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
  1270   1411   ** not create a new trigger context.
  1271   1412   **
  1272         -** This function returns the number of direct row changes in the
         1413  +** ^This function returns the number of direct row changes in the
  1273   1414   ** most recent INSERT, UPDATE, or DELETE statement within the same
  1274   1415   ** trigger context.
  1275   1416   **
  1276         -** Thus, when called from the top level, this function returns the
         1417  +** ^Thus, when called from the top level, this function returns the
  1277   1418   ** number of changes in the most recent INSERT, UPDATE, or DELETE
  1278         -** that also occurred at the top level.  Within the body of a trigger,
         1419  +** that also occurred at the top level.  ^(Within the body of a trigger,
  1279   1420   ** the sqlite3_changes() interface can be called to find the number of
  1280   1421   ** changes in the most recently completed INSERT, UPDATE, or DELETE
  1281   1422   ** statement within the body of the same trigger.
  1282   1423   ** However, the number returned does not include changes
  1283         -** caused by subtriggers since those have their own context.
         1424  +** caused by subtriggers since those have their own context.)^
  1284   1425   **
  1285         -** See also the [sqlite3_total_changes()] interface and the
  1286         -** [count_changes pragma].
  1287         -**
  1288         -** Requirements:
  1289         -** [H12241] [H12243]
         1426  +** See also the [sqlite3_total_changes()] interface, the
         1427  +** [count_changes pragma], and the [changes() SQL function].
  1290   1428   **
  1291   1429   ** If a separate thread makes changes on the same database connection
  1292   1430   ** while [sqlite3_changes()] is running then the value returned
  1293   1431   ** is unpredictable and not meaningful.
  1294   1432   */
  1295         -int sqlite3_changes(sqlite3*);
         1433  +SQLITE_API int sqlite3_changes(sqlite3*);
  1296   1434   
  1297   1435   /*
  1298         -** CAPI3REF: Total Number Of Rows Modified {H12260} <S10600>
         1436  +** CAPI3REF: Total Number Of Rows Modified
  1299   1437   **
  1300         -** This function returns the number of row changes caused by [INSERT],
         1438  +** ^This function returns the number of row changes caused by [INSERT],
  1301   1439   ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
  1302         -** The count includes all changes from all 
  1303         -** [CREATE TRIGGER | trigger] contexts.  However,
         1440  +** ^(The count returned by sqlite3_total_changes() includes all changes
         1441  +** from all [CREATE TRIGGER | trigger] contexts and changes made by
         1442  +** [foreign key actions]. However,
  1304   1443   ** the count does not include changes used to implement [REPLACE] constraints,
  1305   1444   ** do rollbacks or ABORT processing, or [DROP TABLE] processing.  The
  1306   1445   ** count does not include rows of views that fire an [INSTEAD OF trigger],
  1307   1446   ** though if the INSTEAD OF trigger makes changes of its own, those changes 
  1308         -** are counted.
  1309         -** The changes are counted as soon as the statement that makes them is
  1310         -** completed (when the statement handle is passed to [sqlite3_reset()] or
  1311         -** [sqlite3_finalize()]).
         1447  +** are counted.)^
         1448  +** ^The sqlite3_total_changes() function counts the changes as soon as
         1449  +** the statement that makes them is completed (when the statement handle
         1450  +** is passed to [sqlite3_reset()] or [sqlite3_finalize()]).
  1312   1451   **
  1313         -** See also the [sqlite3_changes()] interface and the
  1314         -** [count_changes pragma].
  1315         -**
  1316         -** Requirements:
  1317         -** [H12261] [H12263]
         1452  +** See also the [sqlite3_changes()] interface, the
         1453  +** [count_changes pragma], and the [total_changes() SQL function].
  1318   1454   **
  1319   1455   ** If a separate thread makes changes on the same database connection
  1320   1456   ** while [sqlite3_total_changes()] is running then the value
  1321   1457   ** returned is unpredictable and not meaningful.
  1322   1458   */
  1323         -int sqlite3_total_changes(sqlite3*);
         1459  +SQLITE_API int sqlite3_total_changes(sqlite3*);
  1324   1460   
  1325   1461   /*
  1326         -** CAPI3REF: Interrupt A Long-Running Query {H12270} <S30500>
         1462  +** CAPI3REF: Interrupt A Long-Running Query
  1327   1463   **
  1328         -** This function causes any pending database operation to abort and
         1464  +** ^This function causes any pending database operation to abort and
  1329   1465   ** return at its earliest opportunity. This routine is typically
  1330   1466   ** called in response to a user action such as pressing "Cancel"
  1331   1467   ** or Ctrl-C where the user wants a long query operation to halt
  1332   1468   ** immediately.
  1333   1469   **
  1334         -** It is safe to call this routine from a thread different from the
         1470  +** ^It is safe to call this routine from a thread different from the
  1335   1471   ** thread that is currently running the database operation.  But it
  1336   1472   ** is not safe to call this routine with a [database connection] that
  1337   1473   ** is closed or might close before sqlite3_interrupt() returns.
  1338   1474   **
  1339         -** If an SQL operation is very nearly finished at the time when
         1475  +** ^If an SQL operation is very nearly finished at the time when
  1340   1476   ** sqlite3_interrupt() is called, then it might not have an opportunity
  1341   1477   ** to be interrupted and might continue to completion.
  1342   1478   **
  1343         -** An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
  1344         -** If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
         1479  +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
         1480  +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
  1345   1481   ** that is inside an explicit transaction, then the entire transaction
  1346   1482   ** will be rolled back automatically.
  1347   1483   **
  1348         -** The sqlite3_interrupt(D) call is in effect until all currently running
  1349         -** SQL statements on [database connection] D complete.  Any new SQL statements
         1484  +** ^The sqlite3_interrupt(D) call is in effect until all currently running
         1485  +** SQL statements on [database connection] D complete.  ^Any new SQL statements
  1350   1486   ** that are started after the sqlite3_interrupt() call and before the 
  1351   1487   ** running statements reaches zero are interrupted as if they had been
  1352         -** running prior to the sqlite3_interrupt() call.  New SQL statements
         1488  +** running prior to the sqlite3_interrupt() call.  ^New SQL statements
  1353   1489   ** that are started after the running statement count reaches zero are
  1354   1490   ** not effected by the sqlite3_interrupt().
  1355         -** A call to sqlite3_interrupt(D) that occurs when there are no running
         1491  +** ^A call to sqlite3_interrupt(D) that occurs when there are no running
  1356   1492   ** SQL statements is a no-op and has no effect on SQL statements
  1357   1493   ** that are started after the sqlite3_interrupt() call returns.
  1358   1494   **
  1359         -** Requirements:
  1360         -** [H12271] [H12272]
  1361         -**
  1362   1495   ** If the database connection closes while [sqlite3_interrupt()]
  1363   1496   ** is running then bad things will likely happen.
  1364   1497   */
  1365         -void sqlite3_interrupt(sqlite3*);
         1498  +SQLITE_API void sqlite3_interrupt(sqlite3*);
  1366   1499   
  1367   1500   /*
  1368         -** CAPI3REF: Determine If An SQL Statement Is Complete {H10510} <S70200>
         1501  +** CAPI3REF: Determine If An SQL Statement Is Complete
  1369   1502   **
  1370   1503   ** These routines are useful during command-line input to determine if the
  1371   1504   ** currently entered text seems to form a complete SQL statement or
  1372   1505   ** if additional input is needed before sending the text into
  1373         -** SQLite for parsing.  These routines return 1 if the input string
  1374         -** appears to be a complete SQL statement.  A statement is judged to be
         1506  +** SQLite for parsing.  ^These routines return 1 if the input string
         1507  +** appears to be a complete SQL statement.  ^A statement is judged to be
  1375   1508   ** complete if it ends with a semicolon token and is not a prefix of a
  1376         -** well-formed CREATE TRIGGER statement.  Semicolons that are embedded within
         1509  +** well-formed CREATE TRIGGER statement.  ^Semicolons that are embedded within
  1377   1510   ** string literals or quoted identifier names or comments are not
  1378   1511   ** independent tokens (they are part of the token in which they are
  1379         -** embedded) and thus do not count as a statement terminator.  Whitespace
         1512  +** embedded) and thus do not count as a statement terminator.  ^Whitespace
  1380   1513   ** and comments that follow the final semicolon are ignored.
  1381   1514   **
  1382         -** These routines return 0 if the statement is incomplete.  If a
         1515  +** ^These routines return 0 if the statement is incomplete.  ^If a
  1383   1516   ** memory allocation fails, then SQLITE_NOMEM is returned.
  1384   1517   **
  1385         -** These routines do not parse the SQL statements thus
         1518  +** ^These routines do not parse the SQL statements thus
  1386   1519   ** will not detect syntactically incorrect SQL.
  1387   1520   **
  1388         -** If SQLite has not been initialized using [sqlite3_initialize()] prior 
         1521  +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior 
  1389   1522   ** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
  1390   1523   ** automatically by sqlite3_complete16().  If that initialization fails,
  1391   1524   ** then the return value from sqlite3_complete16() will be non-zero
  1392         -** regardless of whether or not the input SQL is complete.
  1393         -**
  1394         -** Requirements: [H10511] [H10512]
         1525  +** regardless of whether or not the input SQL is complete.)^
  1395   1526   **
  1396   1527   ** The input to [sqlite3_complete()] must be a zero-terminated
  1397   1528   ** UTF-8 string.
  1398   1529   **
  1399   1530   ** The input to [sqlite3_complete16()] must be a zero-terminated
  1400   1531   ** UTF-16 string in native byte order.
  1401   1532   */
  1402         -int sqlite3_complete(const char *sql);
  1403         -int sqlite3_complete16(const void *sql);
         1533  +SQLITE_API int sqlite3_complete(const char *sql);
         1534  +SQLITE_API int sqlite3_complete16(const void *sql);
  1404   1535   
  1405   1536   /*
  1406         -** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {H12310} <S40400>
         1537  +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
  1407   1538   **
  1408         -** This routine sets a callback function that might be invoked whenever
         1539  +** ^This routine sets a callback function that might be invoked whenever
  1409   1540   ** an attempt is made to open a database table that another thread
  1410   1541   ** or process has locked.
  1411   1542   **
  1412         -** If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
  1413         -** is returned immediately upon encountering the lock. If the busy callback
  1414         -** is not NULL, then the callback will be invoked with two arguments.
         1543  +** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
         1544  +** is returned immediately upon encountering the lock.  ^If the busy callback
         1545  +** is not NULL, then the callback might be invoked with two arguments.
  1415   1546   **
  1416         -** The first argument to the handler is a copy of the void* pointer which
  1417         -** is the third argument to sqlite3_busy_handler().  The second argument to
  1418         -** the handler callback is the number of times that the busy handler has
  1419         -** been invoked for this locking event.  If the
         1547  +** ^The first argument to the busy handler is a copy of the void* pointer which
         1548  +** is the third argument to sqlite3_busy_handler().  ^The second argument to
         1549  +** the busy handler callback is the number of times that the busy handler has
         1550  +** been invoked for this locking event.  ^If the
  1420   1551   ** busy callback returns 0, then no additional attempts are made to
  1421   1552   ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
  1422         -** If the callback returns non-zero, then another attempt
         1553  +** ^If the callback returns non-zero, then another attempt
  1423   1554   ** is made to open the database for reading and the cycle repeats.
  1424   1555   **
  1425   1556   ** The presence of a busy handler does not guarantee that it will be invoked
  1426         -** when there is lock contention. If SQLite determines that invoking the busy
         1557  +** when there is lock contention. ^If SQLite determines that invoking the busy
  1427   1558   ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
  1428   1559   ** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler.
  1429   1560   ** Consider a scenario where one process is holding a read lock that
  1430   1561   ** it is trying to promote to a reserved lock and
  1431   1562   ** a second process is holding a reserved lock that it is trying
  1432   1563   ** to promote to an exclusive lock.  The first process cannot proceed
  1433   1564   ** because it is blocked by the second and the second process cannot
  1434   1565   ** proceed because it is blocked by the first.  If both processes
  1435   1566   ** invoke the busy handlers, neither will make any progress.  Therefore,
  1436   1567   ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
  1437   1568   ** will induce the first process to release its read lock and allow
  1438   1569   ** the second process to proceed.
  1439   1570   **
  1440         -** The default busy callback is NULL.
         1571  +** ^The default busy callback is NULL.
  1441   1572   **
  1442         -** The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
         1573  +** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
  1443   1574   ** when SQLite is in the middle of a large transaction where all the
  1444   1575   ** changes will not fit into the in-memory cache.  SQLite will
  1445   1576   ** already hold a RESERVED lock on the database file, but it needs
  1446   1577   ** to promote this lock to EXCLUSIVE so that it can spill cache
  1447   1578   ** pages into the database file without harm to concurrent
  1448         -** readers.  If it is unable to promote the lock, then the in-memory
         1579  +** readers.  ^If it is unable to promote the lock, then the in-memory
  1449   1580   ** cache will be left in an inconsistent state and so the error
  1450   1581   ** code is promoted from the relatively benign [SQLITE_BUSY] to
  1451         -** the more severe [SQLITE_IOERR_BLOCKED].  This error code promotion
         1582  +** the more severe [SQLITE_IOERR_BLOCKED].  ^This error code promotion
  1452   1583   ** forces an automatic rollback of the changes.  See the
  1453   1584   ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError">
  1454   1585   ** CorruptionFollowingBusyError</a> wiki page for a discussion of why
  1455   1586   ** this is important.
  1456   1587   **
  1457         -** There can only be a single busy handler defined for each
         1588  +** ^(There can only be a single busy handler defined for each
  1458   1589   ** [database connection].  Setting a new busy handler clears any
  1459         -** previously set handler.  Note that calling [sqlite3_busy_timeout()]
         1590  +** previously set handler.)^  ^Note that calling [sqlite3_busy_timeout()]
  1460   1591   ** will also set or clear the busy handler.
  1461   1592   **
  1462   1593   ** The busy callback should not take any actions which modify the
  1463   1594   ** database connection that invoked the busy handler.  Any such actions
  1464   1595   ** result in undefined behavior.
  1465   1596   ** 
  1466         -** Requirements:
  1467         -** [H12311] [H12312] [H12314] [H12316] [H12318]
  1468         -**
  1469   1597   ** A busy handler must not close the database connection
  1470   1598   ** or [prepared statement] that invoked the busy handler.
  1471   1599   */
  1472         -int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
         1600  +SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
  1473   1601   
  1474   1602   /*
  1475         -** CAPI3REF: Set A Busy Timeout {H12340} <S40410>
         1603  +** CAPI3REF: Set A Busy Timeout
  1476   1604   **
  1477         -** This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
  1478         -** for a specified amount of time when a table is locked.  The handler
         1605  +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
         1606  +** for a specified amount of time when a table is locked.  ^The handler
  1479   1607   ** will sleep multiple times until at least "ms" milliseconds of sleeping
  1480         -** have accumulated. {H12343} After "ms" milliseconds of sleeping,
         1608  +** have accumulated.  ^After at least "ms" milliseconds of sleeping,
  1481   1609   ** the handler returns 0 which causes [sqlite3_step()] to return
  1482   1610   ** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
  1483   1611   **
  1484         -** Calling this routine with an argument less than or equal to zero
         1612  +** ^Calling this routine with an argument less than or equal to zero
  1485   1613   ** turns off all busy handlers.
  1486   1614   **
  1487         -** There can only be a single busy handler for a particular
         1615  +** ^(There can only be a single busy handler for a particular
  1488   1616   ** [database connection] any any given moment.  If another busy handler
  1489   1617   ** was defined  (using [sqlite3_busy_handler()]) prior to calling
  1490         -** this routine, that other busy handler is cleared.
  1491         -**
  1492         -** Requirements:
  1493         -** [H12341] [H12343] [H12344]
         1618  +** this routine, that other busy handler is cleared.)^
  1494   1619   */
  1495         -int sqlite3_busy_timeout(sqlite3*, int ms);
         1620  +SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
  1496   1621   
  1497   1622   /*
  1498         -** CAPI3REF: Convenience Routines For Running Queries {H12370} <S10000>
         1623  +** CAPI3REF: Convenience Routines For Running Queries
  1499   1624   **
  1500   1625   ** Definition: A <b>result table</b> is memory data structure created by the
  1501   1626   ** [sqlite3_get_table()] interface.  A result table records the
  1502   1627   ** complete query results from one or more queries.
  1503   1628   **
  1504   1629   ** The table conceptually has a number of rows and columns.  But
  1505   1630   ** these numbers are not part of the result table itself.  These
................................................................................
  1539   1664   **        azResult&#91;3] = "43";
  1540   1665   **        azResult&#91;4] = "Bob";
  1541   1666   **        azResult&#91;5] = "28";
  1542   1667   **        azResult&#91;6] = "Cindy";
  1543   1668   **        azResult&#91;7] = "21";
  1544   1669   ** </pre></blockquote>
  1545   1670   **
  1546         -** The sqlite3_get_table() function evaluates one or more
         1671  +** ^The sqlite3_get_table() function evaluates one or more
  1547   1672   ** semicolon-separated SQL statements in the zero-terminated UTF-8
  1548         -** string of its 2nd parameter.  It returns a result table to the
         1673  +** string of its 2nd parameter and returns a result table to the
  1549   1674   ** pointer given in its 3rd parameter.
  1550   1675   **
  1551         -** After the calling function has finished using the result, it should
  1552         -** pass the pointer to the result table to sqlite3_free_table() in order to
         1676  +** After the application has finished with the result from sqlite3_get_table(),
         1677  +** it should pass the result table pointer to sqlite3_free_table() in order to
  1553   1678   ** release the memory that was malloced.  Because of the way the
  1554   1679   ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
  1555   1680   ** function must not try to call [sqlite3_free()] directly.  Only
  1556   1681   ** [sqlite3_free_table()] is able to release the memory properly and safely.
  1557   1682   **
  1558         -** The sqlite3_get_table() interface is implemented as a wrapper around
         1683  +** ^(The sqlite3_get_table() interface is implemented as a wrapper around
  1559   1684   ** [sqlite3_exec()].  The sqlite3_get_table() routine does not have access
  1560   1685   ** to any internal data structures of SQLite.  It uses only the public
  1561   1686   ** interface defined here.  As a consequence, errors that occur in the
  1562   1687   ** wrapper layer outside of the internal [sqlite3_exec()] call are not
  1563         -** reflected in subsequent calls to [sqlite3_errcode()] or [sqlite3_errmsg()].
  1564         -**
  1565         -** Requirements:
  1566         -** [H12371] [H12373] [H12374] [H12376] [H12379] [H12382]
         1688  +** reflected in subsequent calls to [sqlite3_errcode()] or
         1689  +** [sqlite3_errmsg()].)^
  1567   1690   */
  1568         -int sqlite3_get_table(
         1691  +SQLITE_API int sqlite3_get_table(
  1569   1692     sqlite3 *db,          /* An open database */
  1570   1693     const char *zSql,     /* SQL to be evaluated */
  1571   1694     char ***pazResult,    /* Results of the query */
  1572   1695     int *pnRow,           /* Number of result rows written here */
  1573   1696     int *pnColumn,        /* Number of result columns written here */
  1574   1697     char **pzErrmsg       /* Error msg written here */
  1575   1698   );
  1576         -void sqlite3_free_table(char **result);
         1699  +SQLITE_API void sqlite3_free_table(char **result);
  1577   1700   
  1578   1701   /*
  1579         -** CAPI3REF: Formatted String Printing Functions {H17400} <S70000><S20000>
         1702  +** CAPI3REF: Formatted String Printing Functions
  1580   1703   **
  1581         -** These routines are workalikes of the "printf()" family of functions
         1704  +** These routines are work-alikes of the "printf()" family of functions
  1582   1705   ** from the standard C library.
  1583   1706   **
  1584         -** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
         1707  +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
  1585   1708   ** results into memory obtained from [sqlite3_malloc()].
  1586   1709   ** The strings returned by these two routines should be
  1587         -** released by [sqlite3_free()].  Both routines return a
         1710  +** released by [sqlite3_free()].  ^Both routines return a
  1588   1711   ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
  1589   1712   ** memory to hold the resulting string.
  1590   1713   **
  1591         -** In sqlite3_snprintf() routine is similar to "snprintf()" from
         1714  +** ^(In sqlite3_snprintf() routine is similar to "snprintf()" from
  1592   1715   ** the standard C library.  The result is written into the
  1593   1716   ** buffer supplied as the second parameter whose size is given by
  1594   1717   ** the first parameter. Note that the order of the
  1595         -** first two parameters is reversed from snprintf().  This is an
         1718  +** first two parameters is reversed from snprintf().)^  This is an
  1596   1719   ** historical accident that cannot be fixed without breaking
  1597         -** backwards compatibility.  Note also that sqlite3_snprintf()
         1720  +** backwards compatibility.  ^(Note also that sqlite3_snprintf()
  1598   1721   ** returns a pointer to its buffer instead of the number of
  1599         -** characters actually written into the buffer.  We admit that
         1722  +** characters actually written into the buffer.)^  We admit that
  1600   1723   ** the number of characters written would be a more useful return
  1601   1724   ** value but we cannot change the implementation of sqlite3_snprintf()
  1602   1725   ** now without breaking compatibility.
  1603   1726   **
  1604         -** As long as the buffer size is greater than zero, sqlite3_snprintf()
  1605         -** guarantees that the buffer is always zero-terminated.  The first
         1727  +** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
         1728  +** guarantees that the buffer is always zero-terminated.  ^The first
  1606   1729   ** parameter "n" is the total size of the buffer, including space for
  1607   1730   ** the zero terminator.  So the longest string that can be completely
  1608   1731   ** written will be n-1 characters.
  1609   1732   **
  1610   1733   ** These routines all implement some additional formatting
  1611   1734   ** options that are useful for constructing SQL statements.
  1612   1735   ** All of the usual printf() formatting options apply.  In addition, there
  1613   1736   ** is are "%q", "%Q", and "%z" options.
  1614   1737   **
  1615         -** The %q option works like %s in that it substitutes a null-terminated
         1738  +** ^(The %q option works like %s in that it substitutes a null-terminated
  1616   1739   ** string from the argument list.  But %q also doubles every '\'' character.
  1617         -** %q is designed for use inside a string literal.  By doubling each '\''
         1740  +** %q is designed for use inside a string literal.)^  By doubling each '\''
  1618   1741   ** character it escapes that character and allows it to be inserted into
  1619   1742   ** the string.
  1620   1743   **
  1621   1744   ** For example, assume the string variable zText contains text as follows:
  1622   1745   **
  1623   1746   ** <blockquote><pre>
  1624   1747   **  char *zText = "It's a happy day!";
................................................................................
  1645   1768   ** <blockquote><pre>
  1646   1769   **  INSERT INTO table1 VALUES('It's a happy day!');
  1647   1770   ** </pre></blockquote>
  1648   1771   **
  1649   1772   ** This second example is an SQL syntax error.  As a general rule you should
  1650   1773   ** always use %q instead of %s when inserting text into a string literal.
  1651   1774   **
  1652         -** The %Q option works like %q except it also adds single quotes around
         1775  +** ^(The %Q option works like %q except it also adds single quotes around
  1653   1776   ** the outside of the total string.  Additionally, if the parameter in the
  1654   1777   ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
  1655         -** single quotes) in place of the %Q option.  So, for example, one could say:
         1778  +** single quotes).)^  So, for example, one could say:
  1656   1779   **
  1657   1780   ** <blockquote><pre>
  1658   1781   **  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
  1659   1782   **  sqlite3_exec(db, zSQL, 0, 0, 0);
  1660   1783   **  sqlite3_free(zSQL);
  1661   1784   ** </pre></blockquote>
  1662   1785   **
  1663   1786   ** The code above will render a correct SQL statement in the zSQL
  1664   1787   ** variable even if the zText variable is a NULL pointer.
  1665   1788   **
  1666         -** The "%z" formatting option works exactly like "%s" with the
         1789  +** ^(The "%z" formatting option works like "%s" but with the
  1667   1790   ** addition that after the string has been read and copied into
  1668         -** the result, [sqlite3_free()] is called on the input string. {END}
  1669         -**
  1670         -** Requirements:
  1671         -** [H17403] [H17406] [H17407]
         1791  +** the result, [sqlite3_free()] is called on the input string.)^
  1672   1792   */
  1673         -char *sqlite3_mprintf(const char*,...);
  1674         -char *sqlite3_vmprintf(const char*, va_list);
  1675         -char *sqlite3_snprintf(int,char*,const char*, ...);
         1793  +SQLITE_API char *sqlite3_mprintf(const char*,...);
         1794  +SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
         1795  +SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
  1676   1796   
  1677   1797   /*
  1678         -** CAPI3REF: Memory Allocation Subsystem {H17300} <S20000>
         1798  +** CAPI3REF: Memory Allocation Subsystem
  1679   1799   **
  1680         -** The SQLite core  uses these three routines for all of its own
         1800  +** The SQLite core uses these three routines for all of its own
  1681   1801   ** internal memory allocation needs. "Core" in the previous sentence
  1682   1802   ** does not include operating-system specific VFS implementation.  The
  1683   1803   ** Windows VFS uses native malloc() and free() for some operations.
  1684   1804   **
  1685         -** The sqlite3_malloc() routine returns a pointer to a block
         1805  +** ^The sqlite3_malloc() routine returns a pointer to a block
  1686   1806   ** of memory at least N bytes in length, where N is the parameter.
  1687         -** If sqlite3_malloc() is unable to obtain sufficient free
  1688         -** memory, it returns a NULL pointer.  If the parameter N to
         1807  +** ^If sqlite3_malloc() is unable to obtain sufficient free
         1808  +** memory, it returns a NULL pointer.  ^If the parameter N to
  1689   1809   ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
  1690   1810   ** a NULL pointer.
  1691   1811   **
  1692         -** Calling sqlite3_free() with a pointer previously returned
         1812  +** ^Calling sqlite3_free() with a pointer previously returned
  1693   1813   ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
  1694         -** that it might be reused.  The sqlite3_free() routine is
         1814  +** that it might be reused.  ^The sqlite3_free() routine is
  1695   1815   ** a no-op if is called with a NULL pointer.  Passing a NULL pointer
  1696   1816   ** to sqlite3_free() is harmless.  After being freed, memory
  1697   1817   ** should neither be read nor written.  Even reading previously freed
  1698   1818   ** memory might result in a segmentation fault or other severe error.
  1699   1819   ** Memory corruption, a segmentation fault, or other severe error
  1700   1820   ** might result if sqlite3_free() is called with a non-NULL pointer that
  1701   1821   ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
  1702   1822   **
  1703         -** The sqlite3_realloc() interface attempts to resize a
         1823  +** ^(The sqlite3_realloc() interface attempts to resize a
  1704   1824   ** prior memory allocation to be at least N bytes, where N is the
  1705   1825   ** second parameter.  The memory allocation to be resized is the first
  1706         -** parameter.  If the first parameter to sqlite3_realloc()
         1826  +** parameter.)^ ^ If the first parameter to sqlite3_realloc()
  1707   1827   ** is a NULL pointer then its behavior is identical to calling
  1708   1828   ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
  1709         -** If the second parameter to sqlite3_realloc() is zero or
         1829  +** ^If the second parameter to sqlite3_realloc() is zero or
  1710   1830   ** negative then the behavior is exactly the same as calling
  1711   1831   ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
  1712         -** sqlite3_realloc() returns a pointer to a memory allocation
         1832  +** ^sqlite3_realloc() returns a pointer to a memory allocation
  1713   1833   ** of at least N bytes in size or NULL if sufficient memory is unavailable.
  1714         -** If M is the size of the prior allocation, then min(N,M) bytes
         1834  +** ^If M is the size of the prior allocation, then min(N,M) bytes
  1715   1835   ** of the prior allocation are copied into the beginning of buffer returned
  1716   1836   ** by sqlite3_realloc() and the prior allocation is freed.
  1717         -** If sqlite3_realloc() returns NULL, then the prior allocation
         1837  +** ^If sqlite3_realloc() returns NULL, then the prior allocation
  1718   1838   ** is not freed.
  1719   1839   **
  1720         -** The memory returned by sqlite3_malloc() and sqlite3_realloc()
  1721         -** is always aligned to at least an 8 byte boundary. {END}
  1722         -**
  1723         -** The default implementation of the memory allocation subsystem uses
  1724         -** the malloc(), realloc() and free() provided by the standard C library.
  1725         -** {H17382} However, if SQLite is compiled with the
  1726         -** SQLITE_MEMORY_SIZE=<i>NNN</i> C preprocessor macro (where <i>NNN</i>
  1727         -** is an integer), then SQLite create a static array of at least
  1728         -** <i>NNN</i> bytes in size and uses that array for all of its dynamic
  1729         -** memory allocation needs. {END}  Additional memory allocator options
  1730         -** may be added in future releases.
         1840  +** ^The memory returned by sqlite3_malloc() and sqlite3_realloc()
         1841  +** is always aligned to at least an 8 byte boundary.
  1731   1842   **
  1732   1843   ** In SQLite version 3.5.0 and 3.5.1, it was possible to define
  1733   1844   ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
  1734   1845   ** implementation of these routines to be omitted.  That capability
  1735   1846   ** is no longer provided.  Only built-in memory allocators can be used.
  1736   1847   **
  1737   1848   ** The Windows OS interface layer calls
................................................................................
  1738   1849   ** the system malloc() and free() directly when converting
  1739   1850   ** filenames between the UTF-8 encoding used by SQLite
  1740   1851   ** and whatever filename encoding is used by the particular Windows
  1741   1852   ** installation.  Memory allocation errors are detected, but
  1742   1853   ** they are reported back as [SQLITE_CANTOPEN] or
  1743   1854   ** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
  1744   1855   **
  1745         -** Requirements:
  1746         -** [H17303] [H17304] [H17305] [H17306] [H17310] [H17312] [H17315] [H17318]
  1747         -** [H17321] [H17322] [H17323]
  1748         -**
  1749   1856   ** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
  1750   1857   ** must be either NULL or else pointers obtained from a prior
  1751   1858   ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
  1752   1859   ** not yet been released.
  1753   1860   **
  1754   1861   ** The application must not read or write any part of
  1755   1862   ** a block of memory after it has been released using
  1756   1863   ** [sqlite3_free()] or [sqlite3_realloc()].
  1757   1864   */
  1758         -void *sqlite3_malloc(int);
  1759         -void *sqlite3_realloc(void*, int);
  1760         -void sqlite3_free(void*);
         1865  +SQLITE_API void *sqlite3_malloc(int);
         1866  +SQLITE_API void *sqlite3_realloc(void*, int);
         1867  +SQLITE_API void sqlite3_free(void*);
  1761   1868   
  1762   1869   /*
  1763         -** CAPI3REF: Memory Allocator Statistics {H17370} <S30210>
         1870  +** CAPI3REF: Memory Allocator Statistics
  1764   1871   **
  1765   1872   ** SQLite provides these two interfaces for reporting on the status
  1766   1873   ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
  1767   1874   ** routines, which form the built-in memory allocation subsystem.
  1768   1875   **
  1769         -** Requirements:
  1770         -** [H17371] [H17373] [H17374] [H17375]
         1876  +** ^The [sqlite3_memory_used()] routine returns the number of bytes
         1877  +** of memory currently outstanding (malloced but not freed).
         1878  +** ^The [sqlite3_memory_highwater()] routine returns the maximum
         1879  +** value of [sqlite3_memory_used()] since the high-water mark
         1880  +** was last reset.  ^The values returned by [sqlite3_memory_used()] and
         1881  +** [sqlite3_memory_highwater()] include any overhead
         1882  +** added by SQLite in its implementation of [sqlite3_malloc()],
         1883  +** but not overhead added by the any underlying system library
         1884  +** routines that [sqlite3_malloc()] may call.
         1885  +**
         1886  +** ^The memory high-water mark is reset to the current value of
         1887  +** [sqlite3_memory_used()] if and only if the parameter to
         1888  +** [sqlite3_memory_highwater()] is true.  ^The value returned
         1889  +** by [sqlite3_memory_highwater(1)] is the high-water mark
         1890  +** prior to the reset.
  1771   1891   */
  1772         -sqlite3_int64 sqlite3_memory_used(void);
  1773         -sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
         1892  +SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
         1893  +SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
  1774   1894   
  1775   1895   /*
  1776         -** CAPI3REF: Pseudo-Random Number Generator {H17390} <S20000>
         1896  +** CAPI3REF: Pseudo-Random Number Generator
  1777   1897   **
  1778   1898   ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
  1779   1899   ** select random [ROWID | ROWIDs] when inserting new records into a table that
  1780   1900   ** already uses the largest possible [ROWID].  The PRNG is also used for
  1781   1901   ** the build-in random() and randomblob() SQL functions.  This interface allows
  1782   1902   ** applications to access the same PRNG for other purposes.
  1783   1903   **
  1784         -** A call to this routine stores N bytes of randomness into buffer P.
         1904  +** ^A call to this routine stores N bytes of randomness into buffer P.
  1785   1905   **
  1786         -** The first time this routine is invoked (either internally or by
         1906  +** ^The first time this routine is invoked (either internally or by
  1787   1907   ** the application) the PRNG is seeded using randomness obtained
  1788   1908   ** from the xRandomness method of the default [sqlite3_vfs] object.
  1789         -** On all subsequent invocations, the pseudo-randomness is generated
         1909  +** ^On all subsequent invocations, the pseudo-randomness is generated
  1790   1910   ** internally and without recourse to the [sqlite3_vfs] xRandomness
  1791   1911   ** method.
  1792         -**
  1793         -** Requirements:
  1794         -** [H17392]
  1795   1912   */
  1796         -void sqlite3_randomness(int N, void *P);
         1913  +SQLITE_API void sqlite3_randomness(int N, void *P);
  1797   1914   
  1798   1915   /*
  1799         -** CAPI3REF: Compile-Time Authorization Callbacks {H12500} <S70100>
         1916  +** CAPI3REF: Compile-Time Authorization Callbacks
  1800   1917   **
  1801         -** This routine registers a authorizer callback with a particular
         1918  +** ^This routine registers a authorizer callback with a particular
  1802   1919   ** [database connection], supplied in the first argument.
  1803         -** The authorizer callback is invoked as SQL statements are being compiled
         1920  +** ^The authorizer callback is invoked as SQL statements are being compiled
  1804   1921   ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
  1805         -** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  At various
         1922  +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()].  ^At various
  1806   1923   ** points during the compilation process, as logic is being created
  1807   1924   ** to perform various actions, the authorizer callback is invoked to
  1808         -** see if those actions are allowed.  The authorizer callback should
         1925  +** see if those actions are allowed.  ^The authorizer callback should
  1809   1926   ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
  1810   1927   ** specific action but allow the SQL statement to continue to be
  1811   1928   ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
  1812         -** rejected with an error.  If the authorizer callback returns
         1929  +** rejected with an error.  ^If the authorizer callback returns
  1813   1930   ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
  1814   1931   ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
  1815   1932   ** the authorizer will fail with an error message.
  1816   1933   **
  1817   1934   ** When the callback returns [SQLITE_OK], that means the operation
  1818         -** requested is ok.  When the callback returns [SQLITE_DENY], the
         1935  +** requested is ok.  ^When the callback returns [SQLITE_DENY], the
  1819   1936   ** [sqlite3_prepare_v2()] or equivalent call that triggered the
  1820   1937   ** authorizer will fail with an error message explaining that
  1821   1938   ** access is denied. 
  1822   1939   **
  1823         -** The first parameter to the authorizer callback is a copy of the third
  1824         -** parameter to the sqlite3_set_authorizer() interface. The second parameter
         1940  +** ^The first parameter to the authorizer callback is a copy of the third
         1941  +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter
  1825   1942   ** to the callback is an integer [SQLITE_COPY | action code] that specifies
  1826         -** the particular action to be authorized. The third through sixth parameters
         1943  +** the particular action to be authorized. ^The third through sixth parameters
  1827   1944   ** to the callback are zero-terminated strings that contain additional
  1828   1945   ** details about the action to be authorized.
  1829   1946   **
  1830         -** If the action code is [SQLITE_READ]
         1947  +** ^If the action code is [SQLITE_READ]
  1831   1948   ** and the callback returns [SQLITE_IGNORE] then the
  1832   1949   ** [prepared statement] statement is constructed to substitute
  1833   1950   ** a NULL value in place of the table column that would have
  1834   1951   ** been read if [SQLITE_OK] had been returned.  The [SQLITE_IGNORE]
  1835   1952   ** return can be used to deny an untrusted user access to individual
  1836   1953   ** columns of a table.
  1837         -** If the action code is [SQLITE_DELETE] and the callback returns
         1954  +** ^If the action code is [SQLITE_DELETE] and the callback returns
  1838   1955   ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
  1839   1956   ** [truncate optimization] is disabled and all rows are deleted individually.
  1840   1957   **
  1841   1958   ** An authorizer is used when [sqlite3_prepare | preparing]
  1842   1959   ** SQL statements from an untrusted source, to ensure that the SQL statements
  1843   1960   ** do not try to access data they are not allowed to see, or that they do not
  1844   1961   ** try to execute malicious statements that damage the database.  For
................................................................................
  1850   1967   ** disallows everything except [SELECT] statements.
  1851   1968   **
  1852   1969   ** Applications that need to process SQL from untrusted sources
  1853   1970   ** might also consider lowering resource limits using [sqlite3_limit()]
  1854   1971   ** and limiting database size using the [max_page_count] [PRAGMA]
  1855   1972   ** in addition to using an authorizer.
  1856   1973   **
  1857         -** Only a single authorizer can be in place on a database connection
         1974  +** ^(Only a single authorizer can be in place on a database connection
  1858   1975   ** at a time.  Each call to sqlite3_set_authorizer overrides the
  1859         -** previous call.  Disable the authorizer by installing a NULL callback.
         1976  +** previous call.)^  ^Disable the authorizer by installing a NULL callback.
  1860   1977   ** The authorizer is disabled by default.
  1861   1978   **
  1862   1979   ** The authorizer callback must not do anything that will modify
  1863   1980   ** the database connection that invoked the authorizer callback.
  1864   1981   ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
  1865   1982   ** database connections for the meaning of "modify" in this paragraph.
  1866   1983   **
  1867         -** When [sqlite3_prepare_v2()] is used to prepare a statement, the
  1868         -** statement might be reprepared during [sqlite3_step()] due to a 
         1984  +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
         1985  +** statement might be re-prepared during [sqlite3_step()] due to a 
  1869   1986   ** schema change.  Hence, the application should ensure that the
  1870   1987   ** correct authorizer callback remains in place during the [sqlite3_step()].
  1871   1988   **
  1872         -** Note that the authorizer callback is invoked only during
         1989  +** ^Note that the authorizer callback is invoked only during
  1873   1990   ** [sqlite3_prepare()] or its variants.  Authorization is not
  1874   1991   ** performed during statement evaluation in [sqlite3_step()], unless
  1875   1992   ** as stated in the previous paragraph, sqlite3_step() invokes
  1876   1993   ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
  1877         -**
  1878         -** Requirements:
  1879         -** [H12501] [H12502] [H12503] [H12504] [H12505] [H12506] [H12507] [H12510]
  1880         -** [H12511] [H12512] [H12520] [H12521] [H12522]
  1881   1994   */
  1882         -int sqlite3_set_authorizer(
         1995  +SQLITE_API int sqlite3_set_authorizer(
  1883   1996     sqlite3*,
  1884   1997     int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  1885   1998     void *pUserData
  1886   1999   );
  1887   2000   
  1888   2001   /*
  1889         -** CAPI3REF: Authorizer Return Codes {H12590} <H12500>
         2002  +** CAPI3REF: Authorizer Return Codes
  1890   2003   **
  1891   2004   ** The [sqlite3_set_authorizer | authorizer callback function] must
  1892   2005   ** return either [SQLITE_OK] or one of these two constants in order
  1893   2006   ** to signal SQLite whether or not the action is permitted.  See the
  1894   2007   ** [sqlite3_set_authorizer | authorizer documentation] for additional
  1895   2008   ** information.
  1896   2009   */
  1897   2010   #define SQLITE_DENY   1   /* Abort the SQL statement with an error */
  1898   2011   #define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */
  1899   2012   
  1900   2013   /*
  1901         -** CAPI3REF: Authorizer Action Codes {H12550} <H12500>
         2014  +** CAPI3REF: Authorizer Action Codes
  1902   2015   **
  1903   2016   ** The [sqlite3_set_authorizer()] interface registers a callback function
  1904   2017   ** that is invoked to authorize certain SQL statement actions.  The
  1905   2018   ** second parameter to the callback is an integer code that specifies
  1906   2019   ** what action is being authorized.  These are the integer action codes that
  1907   2020   ** the authorizer callback may be passed.
  1908   2021   **
  1909   2022   ** These action code values signify what kind of operation is to be
  1910   2023   ** authorized.  The 3rd and 4th parameters to the authorization
  1911   2024   ** callback function will be parameters or NULL depending on which of these
  1912         -** codes is used as the second parameter.  The 5th parameter to the
         2025  +** codes is used as the second parameter.  ^(The 5th parameter to the
  1913   2026   ** authorizer callback is the name of the database ("main", "temp",
  1914         -** etc.) if applicable.  The 6th parameter to the authorizer callback
         2027  +** etc.) if applicable.)^  ^The 6th parameter to the authorizer callback
  1915   2028   ** is the name of the inner-most trigger or view that is responsible for
  1916   2029   ** the access attempt or NULL if this access attempt is directly from
  1917   2030   ** top-level SQL code.
  1918         -**
  1919         -** Requirements:
  1920         -** [H12551] [H12552] [H12553] [H12554]
  1921   2031   */
  1922   2032   /******************************************* 3rd ************ 4th ***********/
  1923   2033   #define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
  1924   2034   #define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
  1925   2035   #define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
  1926   2036   #define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
  1927   2037   #define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
................................................................................
  1951   2061   #define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
  1952   2062   #define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
  1953   2063   #define SQLITE_FUNCTION             31   /* NULL            Function Name   */
  1954   2064   #define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
  1955   2065   #define SQLITE_COPY                  0   /* No longer used */
  1956   2066   
  1957   2067   /*
  1958         -** CAPI3REF: Tracing And Profiling Functions {H12280} <S60400>
         2068  +** CAPI3REF: Tracing And Profiling Functions
  1959   2069   ** EXPERIMENTAL
  1960   2070   **
  1961   2071   ** These routines register callback functions that can be used for
  1962   2072   ** tracing and profiling the execution of SQL statements.
  1963   2073   **
  1964         -** The callback function registered by sqlite3_trace() is invoked at
         2074  +** ^The callback function registered by sqlite3_trace() is invoked at
  1965   2075   ** various times when an SQL statement is being run by [sqlite3_step()].
  1966         -** The callback returns a UTF-8 rendering of the SQL statement text
  1967         -** as the statement first begins executing.  Additional callbacks occur
         2076  +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
         2077  +** SQL statement text as the statement first begins executing.
         2078  +** ^(Additional sqlite3_trace() callbacks might occur
  1968   2079   ** as each triggered subprogram is entered.  The callbacks for triggers
  1969         -** contain a UTF-8 SQL comment that identifies the trigger.
         2080  +** contain a UTF-8 SQL comment that identifies the trigger.)^
  1970   2081   **
  1971         -** The callback function registered by sqlite3_profile() is invoked
  1972         -** as each SQL statement finishes.  The profile callback contains
         2082  +** ^The callback function registered by sqlite3_profile() is invoked
         2083  +** as each SQL statement finishes.  ^The profile callback contains
  1973   2084   ** the original statement text and an estimate of wall-clock time
  1974   2085   ** of how long that statement took to run.
  1975         -**
  1976         -** Requirements:
  1977         -** [H12281] [H12282] [H12283] [H12284] [H12285] [H12287] [H12288] [H12289]
  1978         -** [H12290]
  1979   2086   */
  1980         -SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
  1981         -SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
         2087  +SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
         2088  +SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
  1982   2089      void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
  1983   2090   
  1984   2091   /*
  1985         -** CAPI3REF: Query Progress Callbacks {H12910} <S60400>
         2092  +** CAPI3REF: Query Progress Callbacks
  1986   2093   **
  1987         -** This routine configures a callback function - the
         2094  +** ^This routine configures a callback function - the
  1988   2095   ** progress callback - that is invoked periodically during long
  1989   2096   ** running calls to [sqlite3_exec()], [sqlite3_step()] and
  1990   2097   ** [sqlite3_get_table()].  An example use for this
  1991   2098   ** interface is to keep a GUI updated during a large query.
  1992   2099   **
  1993         -** If the progress callback returns non-zero, the operation is
         2100  +** ^If the progress callback returns non-zero, the operation is
  1994   2101   ** interrupted.  This feature can be used to implement a
  1995   2102   ** "Cancel" button on a GUI progress dialog box.
  1996   2103   **
  1997   2104   ** The progress handler must not do anything that will modify
  1998   2105   ** the database connection that invoked the progress handler.
  1999   2106   ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
  2000   2107   ** database connections for the meaning of "modify" in this paragraph.
  2001   2108   **
  2002         -** Requirements:
  2003         -** [H12911] [H12912] [H12913] [H12914] [H12915] [H12916] [H12917] [H12918]
  2004         -**
  2005   2109   */
  2006         -void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
         2110  +SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
  2007   2111   
  2008   2112   /*
  2009         -** CAPI3REF: Opening A New Database Connection {H12700} <S40200>
         2113  +** CAPI3REF: Opening A New Database Connection
  2010   2114   **
  2011         -** These routines open an SQLite database file whose name is given by the
  2012         -** filename argument. The filename argument is interpreted as UTF-8 for
         2115  +** ^These routines open an SQLite database file whose name is given by the
         2116  +** filename argument. ^The filename argument is interpreted as UTF-8 for
  2013   2117   ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
  2014         -** order for sqlite3_open16(). A [database connection] handle is usually
         2118  +** order for sqlite3_open16(). ^(A [database connection] handle is usually
  2015   2119   ** returned in *ppDb, even if an error occurs.  The only exception is that
  2016   2120   ** if SQLite is unable to allocate memory to hold the [sqlite3] object,
  2017   2121   ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
  2018         -** object. If the database is opened (and/or created) successfully, then
  2019         -** [SQLITE_OK] is returned.  Otherwise an [error code] is returned.  The
         2122  +** object.)^ ^(If the database is opened (and/or created) successfully, then
         2123  +** [SQLITE_OK] is returned.  Otherwise an [error code] is returned.)^ ^The
  2020   2124   ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
  2021         -** an English language description of the error.
         2125  +** an English language description of the error following a failure of any
         2126  +** of the sqlite3_open() routines.
  2022   2127   **
  2023         -** The default encoding for the database will be UTF-8 if
         2128  +** ^The default encoding for the database will be UTF-8 if
  2024   2129   ** sqlite3_open() or sqlite3_open_v2() is called and
  2025   2130   ** UTF-16 in the native byte order if sqlite3_open16() is used.
  2026   2131   **
  2027   2132   ** Whether or not an error occurs when it is opened, resources
  2028   2133   ** associated with the [database connection] handle should be released by
  2029   2134   ** passing it to [sqlite3_close()] when it is no longer required.
  2030   2135   **
  2031   2136   ** The sqlite3_open_v2() interface works like sqlite3_open()
  2032   2137   ** except that it accepts two additional parameters for additional control
  2033         -** over the new database connection.  The flags parameter can take one of
         2138  +** over the new database connection.  ^(The flags parameter to
         2139  +** sqlite3_open_v2() can take one of
  2034   2140   ** the following three values, optionally combined with the 
  2035         -** [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags:
         2141  +** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
         2142  +** and/or [SQLITE_OPEN_PRIVATECACHE] flags:)^
  2036   2143   **
  2037   2144   ** <dl>
  2038         -** <dt>[SQLITE_OPEN_READONLY]</dt>
         2145  +** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
  2039   2146   ** <dd>The database is opened in read-only mode.  If the database does not
  2040         -** already exist, an error is returned.</dd>
         2147  +** already exist, an error is returned.</dd>)^
  2041   2148   **
  2042         -** <dt>[SQLITE_OPEN_READWRITE]</dt>
         2149  +** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
  2043   2150   ** <dd>The database is opened for reading and writing if possible, or reading
  2044   2151   ** only if the file is write protected by the operating system.  In either
  2045         -** case the database must already exist, otherwise an error is returned.</dd>
         2152  +** case the database must already exist, otherwise an error is returned.</dd>)^
  2046   2153   **
  2047         -** <dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
         2154  +** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
  2048   2155   ** <dd>The database is opened for reading and writing, and is creates it if
  2049   2156   ** it does not already exist. This is the behavior that is always used for
  2050         -** sqlite3_open() and sqlite3_open16().</dd>
         2157  +** sqlite3_open() and sqlite3_open16().</dd>)^
  2051   2158   ** </dl>
  2052   2159   **
  2053   2160   ** If the 3rd parameter to sqlite3_open_v2() is not one of the
  2054   2161   ** combinations shown above or one of the combinations shown above combined
  2055         -** with the [SQLITE_OPEN_NOMUTEX] or [SQLITE_OPEN_FULLMUTEX] flags,
         2162  +** with the [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX],
         2163  +** [SQLITE_OPEN_SHAREDCACHE] and/or [SQLITE_OPEN_SHAREDCACHE] flags,
  2056   2164   ** then the behavior is undefined.
  2057   2165   **
  2058         -** If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
         2166  +** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
  2059   2167   ** opens in the multi-thread [threading mode] as long as the single-thread
  2060         -** mode has not been set at compile-time or start-time.  If the
         2168  +** mode has not been set at compile-time or start-time.  ^If the
  2061   2169   ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
  2062   2170   ** in the serialized [threading mode] unless single-thread was
  2063   2171   ** previously selected at compile-time or start-time.
         2172  +** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
         2173  +** eligible to use [shared cache mode], regardless of whether or not shared
         2174  +** cache is enabled using [sqlite3_enable_shared_cache()].  ^The
         2175  +** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
         2176  +** participate in [shared cache mode] even if it is enabled.
  2064   2177   **
  2065         -** If the filename is ":memory:", then a private, temporary in-memory database
  2066         -** is created for the connection.  This in-memory database will vanish when
         2178  +** ^If the filename is ":memory:", then a private, temporary in-memory database
         2179  +** is created for the connection.  ^This in-memory database will vanish when
  2067   2180   ** the database connection is closed.  Future versions of SQLite might
  2068   2181   ** make use of additional special filenames that begin with the ":" character.
  2069   2182   ** It is recommended that when a database filename actually does begin with
  2070   2183   ** a ":" character you should prefix the filename with a pathname such as
  2071   2184   ** "./" to avoid ambiguity.
  2072   2185   **
  2073         -** If the filename is an empty string, then a private, temporary
  2074         -** on-disk database will be created.  This private database will be
         2186  +** ^If the filename is an empty string, then a private, temporary
         2187  +** on-disk database will be created.  ^This private database will be
  2075   2188   ** automatically deleted as soon as the database connection is closed.
  2076   2189   **
  2077         -** The fourth parameter to sqlite3_open_v2() is the name of the
         2190  +** ^The fourth parameter to sqlite3_open_v2() is the name of the
  2078   2191   ** [sqlite3_vfs] object that defines the operating system interface that
  2079         -** the new database connection should use.  If the fourth parameter is
         2192  +** the new database connection should use.  ^If the fourth parameter is
  2080   2193   ** a NULL pointer then the default [sqlite3_vfs] object is used.
  2081   2194   **
  2082   2195   ** <b>Note to Windows users:</b>  The encoding used for the filename argument
  2083   2196   ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
  2084   2197   ** codepage is currently defined.  Filenames containing international
  2085   2198   ** characters must be converted to UTF-8 prior to passing them into
  2086   2199   ** sqlite3_open() or sqlite3_open_v2().
  2087         -**
  2088         -** Requirements:
  2089         -** [H12701] [H12702] [H12703] [H12704] [H12706] [H12707] [H12709] [H12711]
  2090         -** [H12712] [H12713] [H12714] [H12717] [H12719] [H12721] [H12723]
  2091   2200   */
  2092         -int sqlite3_open(
         2201  +SQLITE_API int sqlite3_open(
  2093   2202     const char *filename,   /* Database filename (UTF-8) */
  2094   2203     sqlite3 **ppDb          /* OUT: SQLite db handle */
  2095   2204   );
  2096         -int sqlite3_open16(
         2205  +SQLITE_API int sqlite3_open16(
  2097   2206     const void *filename,   /* Database filename (UTF-16) */
  2098   2207     sqlite3 **ppDb          /* OUT: SQLite db handle */
  2099   2208   );
  2100         -int sqlite3_open_v2(
         2209  +SQLITE_API int sqlite3_open_v2(
  2101   2210     const char *filename,   /* Database filename (UTF-8) */
  2102   2211     sqlite3 **ppDb,         /* OUT: SQLite db handle */
  2103   2212     int flags,              /* Flags */
  2104   2213     const char *zVfs        /* Name of VFS module to use */
  2105   2214   );
  2106   2215   
  2107   2216   /*
  2108         -** CAPI3REF: Error Codes And Messages {H12800} <S60200>
         2217  +** CAPI3REF: Error Codes And Messages
  2109   2218   **
  2110         -** The sqlite3_errcode() interface returns the numeric [result code] or
         2219  +** ^The sqlite3_errcode() interface returns the numeric [result code] or
  2111   2220   ** [extended result code] for the most recent failed sqlite3_* API call
  2112   2221   ** associated with a [database connection]. If a prior API call failed
  2113   2222   ** but the most recent API call succeeded, the return value from
  2114         -** sqlite3_errcode() is undefined.  The sqlite3_extended_errcode()
         2223  +** sqlite3_errcode() is undefined.  ^The sqlite3_extended_errcode()
  2115   2224   ** interface is the same except that it always returns the 
  2116   2225   ** [extended result code] even when extended result codes are
  2117   2226   ** disabled.
  2118   2227   **
  2119         -** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
         2228  +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
  2120   2229   ** text that describes the error, as either UTF-8 or UTF-16 respectively.
  2121         -** Memory to hold the error message string is managed internally.
         2230  +** ^(Memory to hold the error message string is managed internally.
  2122   2231   ** The application does not need to worry about freeing the result.
  2123   2232   ** However, the error string might be overwritten or deallocated by
  2124         -** subsequent calls to other SQLite interface functions.
         2233  +** subsequent calls to other SQLite interface functions.)^
  2125   2234   **
  2126   2235   ** When the serialized [threading mode] is in use, it might be the
  2127   2236   ** case that a second error occurs on a separate thread in between
  2128   2237   ** the time of the first error and the call to these interfaces.
  2129   2238   ** When that happens, the second error will be reported since these
  2130   2239   ** interfaces always report the most recent result.  To avoid
  2131   2240   ** this, each thread can obtain exclusive use of the [database connection] D
................................................................................
  2132   2241   ** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
  2133   2242   ** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
  2134   2243   ** all calls to the interfaces listed here are completed.
  2135   2244   **
  2136   2245   ** If an interface fails with SQLITE_MISUSE, that means the interface
  2137   2246   ** was invoked incorrectly by the application.  In that case, the
  2138   2247   ** error code and message may or may not be set.
  2139         -**
  2140         -** Requirements:
  2141         -** [H12801] [H12802] [H12803] [H12807] [H12808] [H12809]
  2142   2248   */
  2143         -int sqlite3_errcode(sqlite3 *db);
  2144         -int sqlite3_extended_errcode(sqlite3 *db);
  2145         -const char *sqlite3_errmsg(sqlite3*);
  2146         -const void *sqlite3_errmsg16(sqlite3*);
         2249  +SQLITE_API int sqlite3_errcode(sqlite3 *db);
         2250  +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
         2251  +SQLITE_API const char *sqlite3_errmsg(sqlite3*);
         2252  +SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
  2147   2253   
  2148   2254   /*
  2149         -** CAPI3REF: SQL Statement Object {H13000} <H13010>
         2255  +** CAPI3REF: SQL Statement Object
  2150   2256   ** KEYWORDS: {prepared statement} {prepared statements}
  2151   2257   **
  2152   2258   ** An instance of this object represents a single SQL statement.
  2153   2259   ** This object is variously known as a "prepared statement" or a
  2154   2260   ** "compiled SQL statement" or simply as a "statement".
  2155   2261   **
  2156   2262   ** The life of a statement object goes something like this:
................................................................................
  2168   2274   **
  2169   2275   ** Refer to documentation on individual methods above for additional
  2170   2276   ** information.
  2171   2277   */
  2172   2278   typedef struct sqlite3_stmt sqlite3_stmt;
  2173   2279   
  2174   2280   /*
  2175         -** CAPI3REF: Run-time Limits {H12760} <S20600>
         2281  +** CAPI3REF: Run-time Limits
  2176   2282   **
  2177         -** This interface allows the size of various constructs to be limited
         2283  +** ^(This interface allows the size of various constructs to be limited
  2178   2284   ** on a connection by connection basis.  The first parameter is the
  2179   2285   ** [database connection] whose limit is to be set or queried.  The
  2180   2286   ** second parameter is one of the [limit categories] that define a
  2181   2287   ** class of constructs to be size limited.  The third parameter is the
  2182         -** new limit for that construct.  The function returns the old limit.
         2288  +** new limit for that construct.  The function returns the old limit.)^
  2183   2289   **
  2184         -** If the new limit is a negative number, the limit is unchanged.
  2185         -** For the limit category of SQLITE_LIMIT_XYZ there is a 
         2290  +** ^If the new limit is a negative number, the limit is unchanged.
         2291  +** ^(For the limit category of SQLITE_LIMIT_XYZ there is a 
  2186   2292   ** [limits | hard upper bound]
  2187   2293   ** set by a compile-time C preprocessor macro named 
  2188   2294   ** [limits | SQLITE_MAX_XYZ].
  2189         -** (The "_LIMIT_" in the name is changed to "_MAX_".)
  2190         -** Attempts to increase a limit above its hard upper bound are
  2191         -** silently truncated to the hard upper limit.
         2295  +** (The "_LIMIT_" in the name is changed to "_MAX_".))^
         2296  +** ^Attempts to increase a limit above its hard upper bound are
         2297  +** silently truncated to the hard upper bound.
  2192   2298   **
  2193         -** Run time limits are intended for use in applications that manage
         2299  +** Run-time limits are intended for use in applications that manage
  2194   2300   ** both their own internal database and also databases that are controlled
  2195   2301   ** by untrusted external sources.  An example application might be a
  2196   2302   ** web browser that has its own databases for storing history and
  2197   2303   ** separate databases controlled by JavaScript applications downloaded
  2198   2304   ** off the Internet.  The internal databases can be given the
  2199   2305   ** large, default limits.  Databases managed by external sources can
  2200   2306   ** be given much smaller limits designed to prevent a denial of service
  2201   2307   ** attack.  Developers might also want to use the [sqlite3_set_authorizer()]
  2202   2308   ** interface to further control untrusted SQL.  The size of the database
  2203   2309   ** created by an untrusted script can be contained using the
  2204   2310   ** [max_page_count] [PRAGMA].
  2205   2311   **
  2206   2312   ** New run-time limit categories may be added in future releases.
  2207         -**
  2208         -** Requirements:
  2209         -** [H12762] [H12766] [H12769]
  2210   2313   */
  2211         -int sqlite3_limit(sqlite3*, int id, int newVal);
         2314  +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
  2212   2315   
  2213   2316   /*
  2214         -** CAPI3REF: Run-Time Limit Categories {H12790} <H12760>
  2215         -** KEYWORDS: {limit category} {limit categories}
         2317  +** CAPI3REF: Run-Time Limit Categories
         2318  +** KEYWORDS: {limit category} {*limit categories}
  2216   2319   **
  2217   2320   ** These constants define various performance limits
  2218   2321   ** that can be lowered at run-time using [sqlite3_limit()].
  2219   2322   ** The synopsis of the meanings of the various limits is shown below.
  2220   2323   ** Additional information is available at [limits | Limits in SQLite].
  2221   2324   **
  2222   2325   ** <dl>
  2223         -** <dt>SQLITE_LIMIT_LENGTH</dt>
  2224         -** <dd>The maximum size of any string or BLOB or table row.<dd>
         2326  +** ^(<dt>SQLITE_LIMIT_LENGTH</dt>
         2327  +** <dd>The maximum size of any string or BLOB or table row.<dd>)^
  2225   2328   **
  2226         -** <dt>SQLITE_LIMIT_SQL_LENGTH</dt>
  2227         -** <dd>The maximum length of an SQL statement.</dd>
         2329  +** ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
         2330  +** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
  2228   2331   **
  2229         -** <dt>SQLITE_LIMIT_COLUMN</dt>
         2332  +** ^(<dt>SQLITE_LIMIT_COLUMN</dt>
  2230   2333   ** <dd>The maximum number of columns in a table definition or in the
  2231   2334   ** result set of a [SELECT] or the maximum number of columns in an index
  2232         -** or in an ORDER BY or GROUP BY clause.</dd>
         2335  +** or in an ORDER BY or GROUP BY clause.</dd>)^
  2233   2336   **
  2234         -** <dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
  2235         -** <dd>The maximum depth of the parse tree on any expression.</dd>
         2337  +** ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
         2338  +** <dd>The maximum depth of the parse tree on any expression.</dd>)^
  2236   2339   **
  2237         -** <dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
  2238         -** <dd>The maximum number of terms in a compound SELECT statement.</dd>
         2340  +** ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
         2341  +** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
  2239   2342   **
  2240         -** <dt>SQLITE_LIMIT_VDBE_OP</dt>
         2343  +** ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
  2241   2344   ** <dd>The maximum number of instructions in a virtual machine program
  2242         -** used to implement an SQL statement.</dd>
         2345  +** used to implement an SQL statement.</dd>)^
  2243   2346   **
  2244         -** <dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
  2245         -** <dd>The maximum number of arguments on a function.</dd>
         2347  +** ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
         2348  +** <dd>The maximum number of arguments on a function.</dd>)^
  2246   2349   **
  2247         -** <dt>SQLITE_LIMIT_ATTACHED</dt>
  2248         -** <dd>The maximum number of [ATTACH | attached databases].</dd>
         2350  +** ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
         2351  +** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
  2249   2352   **
  2250         -** <dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
         2353  +** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
  2251   2354   ** <dd>The maximum length of the pattern argument to the [LIKE] or
  2252         -** [GLOB] operators.</dd>
         2355  +** [GLOB] operators.</dd>)^
  2253   2356   **
  2254         -** <dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
         2357  +** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
  2255   2358   ** <dd>The maximum number of variables in an SQL statement that can
  2256         -** be bound.</dd>
         2359  +** be bound.</dd>)^
         2360  +**
         2361  +** ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
         2362  +** <dd>The maximum depth of recursion for triggers.</dd>)^
  2257   2363   ** </dl>
  2258   2364   */
  2259   2365   #define SQLITE_LIMIT_LENGTH                    0
  2260   2366   #define SQLITE_LIMIT_SQL_LENGTH                1
  2261   2367   #define SQLITE_LIMIT_COLUMN                    2
  2262   2368   #define SQLITE_LIMIT_EXPR_DEPTH                3
  2263   2369   #define SQLITE_LIMIT_COMPOUND_SELECT           4
  2264   2370   #define SQLITE_LIMIT_VDBE_OP                   5
  2265   2371   #define SQLITE_LIMIT_FUNCTION_ARG              6
  2266   2372   #define SQLITE_LIMIT_ATTACHED                  7
  2267   2373   #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
  2268   2374   #define SQLITE_LIMIT_VARIABLE_NUMBER           9
         2375  +#define SQLITE_LIMIT_TRIGGER_DEPTH            10
  2269   2376   
  2270   2377   /*
  2271         -** CAPI3REF: Compiling An SQL Statement {H13010} <S10000>
         2378  +** CAPI3REF: Compiling An SQL Statement
  2272   2379   ** KEYWORDS: {SQL statement compiler}
  2273   2380   **
  2274   2381   ** To execute an SQL query, it must first be compiled into a byte-code
  2275   2382   ** program using one of these routines.
  2276   2383   **
  2277   2384   ** The first argument, "db", is a [database connection] obtained from a
  2278   2385   ** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
................................................................................
  2279   2386   ** [sqlite3_open16()].  The database connection must not have been closed.
  2280   2387   **
  2281   2388   ** The second argument, "zSql", is the statement to be compiled, encoded
  2282   2389   ** as either UTF-8 or UTF-16.  The sqlite3_prepare() and sqlite3_prepare_v2()
  2283   2390   ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
  2284   2391   ** use UTF-16.
  2285   2392   **
  2286         -** If the nByte argument is less than zero, then zSql is read up to the
  2287         -** first zero terminator. If nByte is non-negative, then it is the maximum
  2288         -** number of  bytes read from zSql.  When nByte is non-negative, the
         2393  +** ^If the nByte argument is less than zero, then zSql is read up to the
         2394  +** first zero terminator. ^If nByte is non-negative, then it is the maximum
         2395  +** number of  bytes read from zSql.  ^When nByte is non-negative, the
  2289   2396   ** zSql string ends at either the first '\000' or '\u0000' character or
  2290   2397   ** the nByte-th byte, whichever comes first. If the caller knows
  2291   2398   ** that the supplied string is nul-terminated, then there is a small
  2292   2399   ** performance advantage to be gained by passing an nByte parameter that
  2293   2400   ** is equal to the number of bytes in the input string <i>including</i>
  2294   2401   ** the nul-terminator bytes.
  2295   2402   **
  2296         -** If pzTail is not NULL then *pzTail is made to point to the first byte
         2403  +** ^If pzTail is not NULL then *pzTail is made to point to the first byte
  2297   2404   ** past the end of the first SQL statement in zSql.  These routines only
  2298   2405   ** compile the first statement in zSql, so *pzTail is left pointing to
  2299   2406   ** what remains uncompiled.
  2300   2407   **
  2301         -** *ppStmt is left pointing to a compiled [prepared statement] that can be
  2302         -** executed using [sqlite3_step()].  If there is an error, *ppStmt is set
  2303         -** to NULL.  If the input text contains no SQL (if the input is an empty
         2408  +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be
         2409  +** executed using [sqlite3_step()].  ^If there is an error, *ppStmt is set
         2410  +** to NULL.  ^If the input text contains no SQL (if the input is an empty
  2304   2411   ** string or a comment) then *ppStmt is set to NULL.
  2305   2412   ** The calling procedure is responsible for deleting the compiled
  2306   2413   ** SQL statement using [sqlite3_finalize()] after it has finished with it.
  2307   2414   ** ppStmt may not be NULL.
  2308   2415   **
  2309         -** On success, [SQLITE_OK] is returned, otherwise an [error code] is returned.
         2416  +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
         2417  +** otherwise an [error code] is returned.
  2310   2418   **
  2311   2419   ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
  2312   2420   ** recommended for all new programs. The two older interfaces are retained
  2313   2421   ** for backwards compatibility, but their use is discouraged.
  2314         -** In the "v2" interfaces, the prepared statement
         2422  +** ^In the "v2" interfaces, the prepared statement
  2315   2423   ** that is returned (the [sqlite3_stmt] object) contains a copy of the
  2316   2424   ** original SQL text. This causes the [sqlite3_step()] interface to
  2317         -** behave a differently in two ways:
         2425  +** behave differently in three ways:
  2318   2426   **
  2319   2427   ** <ol>
  2320   2428   ** <li>
  2321         -** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
         2429  +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
  2322   2430   ** always used to do, [sqlite3_step()] will automatically recompile the SQL
  2323         -** statement and try to run it again.  If the schema has changed in
         2431  +** statement and try to run it again.  ^If the schema has changed in
  2324   2432   ** a way that makes the statement no longer valid, [sqlite3_step()] will still
  2325   2433   ** return [SQLITE_SCHEMA].  But unlike the legacy behavior, [SQLITE_SCHEMA] is
  2326   2434   ** now a fatal error.  Calling [sqlite3_prepare_v2()] again will not make the
  2327   2435   ** error go away.  Note: use [sqlite3_errmsg()] to find the text
  2328   2436   ** of the parsing error that results in an [SQLITE_SCHEMA] return.
  2329   2437   ** </li>
  2330   2438   **
  2331   2439   ** <li>
  2332         -** When an error occurs, [sqlite3_step()] will return one of the detailed
  2333         -** [error codes] or [extended error codes].  The legacy behavior was that
         2440  +** ^When an error occurs, [sqlite3_step()] will return one of the detailed
         2441  +** [error codes] or [extended error codes].  ^The legacy behavior was that
  2334   2442   ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
  2335         -** and you would have to make a second call to [sqlite3_reset()] in order
  2336         -** to find the underlying cause of the problem. With the "v2" prepare
         2443  +** and the application would have to make a second call to [sqlite3_reset()]
         2444  +** in order to find the underlying cause of the problem. With the "v2" prepare
  2337   2445   ** interfaces, the underlying reason for the error is returned immediately.
  2338   2446   ** </li>
         2447  +**
         2448  +** <li>
         2449  +** ^If the value of a [parameter | host parameter] in the WHERE clause might
         2450  +** change the query plan for a statement, then the statement may be
         2451  +** automatically recompiled (as if there had been a schema change) on the first 
         2452  +** [sqlite3_step()] call following any change to the 
         2453  +** [sqlite3_bind_text | bindings] of the [parameter]. 
         2454  +** </li>
  2339   2455   ** </ol>
  2340         -**
  2341         -** Requirements:
  2342         -** [H13011] [H13012] [H13013] [H13014] [H13015] [H13016] [H13019] [H13021]
  2343         -**
  2344   2456   */
  2345         -int sqlite3_prepare(
         2457  +SQLITE_API int sqlite3_prepare(
         2458  +  sqlite3 *db,            /* Database handle */
         2459  +  const char *zSql,       /* SQL statement, UTF-8 encoded */
         2460  +  int nByte,              /* Maximum length of zSql in bytes. */
         2461  +  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
         2462  +  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
         2463  +);
         2464  +SQLITE_API int sqlite3_prepare_v2(
  2346   2465     sqlite3 *db,            /* Database handle */
  2347   2466     const char *zSql,       /* SQL statement, UTF-8 encoded */
  2348   2467     int nByte,              /* Maximum length of zSql in bytes. */
  2349   2468     sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  2350   2469     const char **pzTail     /* OUT: Pointer to unused portion of zSql */
  2351   2470   );
  2352         -int sqlite3_prepare_v2(
  2353         -  sqlite3 *db,            /* Database handle */
  2354         -  const char *zSql,       /* SQL statement, UTF-8 encoded */
  2355         -  int nByte,              /* Maximum length of zSql in bytes. */
  2356         -  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  2357         -  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
  2358         -);
  2359         -int sqlite3_prepare16(
         2471  +SQLITE_API int sqlite3_prepare16(
  2360   2472     sqlite3 *db,            /* Database handle */
  2361   2473     const void *zSql,       /* SQL statement, UTF-16 encoded */
  2362   2474     int nByte,              /* Maximum length of zSql in bytes. */
  2363   2475     sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  2364   2476     const void **pzTail     /* OUT: Pointer to unused portion of zSql */
  2365   2477   );
  2366         -int sqlite3_prepare16_v2(
         2478  +SQLITE_API int sqlite3_prepare16_v2(
  2367   2479     sqlite3 *db,            /* Database handle */
  2368   2480     const void *zSql,       /* SQL statement, UTF-16 encoded */
  2369   2481     int nByte,              /* Maximum length of zSql in bytes. */
  2370   2482     sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  2371   2483     const void **pzTail     /* OUT: Pointer to unused portion of zSql */
  2372   2484   );
  2373   2485   
  2374   2486   /*
  2375         -** CAPI3REF: Retrieving Statement SQL {H13100} <H13000>
         2487  +** CAPI3REF: Retrieving Statement SQL
  2376   2488   **
  2377         -** This interface can be used to retrieve a saved copy of the original
         2489  +** ^This interface can be used to retrieve a saved copy of the original
  2378   2490   ** SQL text used to create a [prepared statement] if that statement was
  2379   2491   ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
  2380         -**
  2381         -** Requirements:
  2382         -** [H13101] [H13102] [H13103]
  2383   2492   */
  2384         -const char *sqlite3_sql(sqlite3_stmt *pStmt);
         2493  +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
  2385   2494   
  2386   2495   /*
  2387         -** CAPI3REF: Dynamically Typed Value Object {H15000} <S20200>
         2496  +** CAPI3REF: Dynamically Typed Value Object
  2388   2497   ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
  2389   2498   **
  2390   2499   ** SQLite uses the sqlite3_value object to represent all values
  2391   2500   ** that can be stored in a database table. SQLite uses dynamic typing
  2392         -** for the values it stores. Values stored in sqlite3_value objects
         2501  +** for the values it stores.  ^Values stored in sqlite3_value objects
  2393   2502   ** can be integers, floating point values, strings, BLOBs, or NULL.
  2394   2503   **
  2395   2504   ** An sqlite3_value object may be either "protected" or "unprotected".
  2396   2505   ** Some interfaces require a protected sqlite3_value.  Other interfaces
  2397   2506   ** will accept either a protected or an unprotected sqlite3_value.
  2398   2507   ** Every interface that accepts sqlite3_value arguments specifies
  2399   2508   ** whether or not it requires a protected sqlite3_value.
................................................................................
  2407   2516   ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
  2408   2517   ** then there is no distinction between protected and unprotected
  2409   2518   ** sqlite3_value objects and they can be used interchangeably.  However,
  2410   2519   ** for maximum code portability it is recommended that applications
  2411   2520   ** still make the distinction between between protected and unprotected
  2412   2521   ** sqlite3_value objects even when not strictly required.
  2413   2522   **
  2414         -** The sqlite3_value objects that are passed as parameters into the
         2523  +** ^The sqlite3_value objects that are passed as parameters into the
  2415   2524   ** implementation of [application-defined SQL functions] are protected.
  2416         -** The sqlite3_value object returned by
         2525  +** ^The sqlite3_value object returned by
  2417   2526   ** [sqlite3_column_value()] is unprotected.
  2418   2527   ** Unprotected sqlite3_value objects may only be used with
  2419   2528   ** [sqlite3_result_value()] and [sqlite3_bind_value()].
  2420   2529   ** The [sqlite3_value_blob | sqlite3_value_type()] family of
  2421   2530   ** interfaces require protected sqlite3_value objects.
  2422   2531   */
  2423   2532   typedef struct Mem sqlite3_value;
  2424   2533   
  2425   2534   /*
  2426         -** CAPI3REF: SQL Function Context Object {H16001} <S20200>
         2535  +** CAPI3REF: SQL Function Context Object
  2427   2536   **
  2428   2537   ** The context in which an SQL function executes is stored in an
  2429         -** sqlite3_context object.  A pointer to an sqlite3_context object
         2538  +** sqlite3_context object.  ^A pointer to an sqlite3_context object
  2430   2539   ** is always first parameter to [application-defined SQL functions].
  2431   2540   ** The application-defined SQL function implementation will pass this
  2432   2541   ** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
  2433   2542   ** [sqlite3_aggregate_context()], [sqlite3_user_data()],
  2434   2543   ** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
  2435   2544   ** and/or [sqlite3_set_auxdata()].
  2436   2545   */
  2437   2546   typedef struct sqlite3_context sqlite3_context;
  2438   2547   
  2439   2548   /*
  2440         -** CAPI3REF: Binding Values To Prepared Statements {H13500} <S70300>
         2549  +** CAPI3REF: Binding Values To Prepared Statements
  2441   2550   ** KEYWORDS: {host parameter} {host parameters} {host parameter name}
  2442   2551   ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
  2443   2552   **
  2444         -** In the SQL strings input to [sqlite3_prepare_v2()] and its variants,
  2445         -** literals may be replaced by a [parameter] in one of these forms:
         2553  +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
         2554  +** literals may be replaced by a [parameter] that matches one of following
         2555  +** templates:
  2446   2556   **
  2447   2557   ** <ul>
  2448   2558   ** <li>  ?
  2449   2559   ** <li>  ?NNN
  2450   2560   ** <li>  :VVV
  2451   2561   ** <li>  @VVV
  2452   2562   ** <li>  $VVV
  2453   2563   ** </ul>
  2454   2564   **
  2455         -** In the parameter forms shown above NNN is an integer literal,
  2456         -** and VVV is an alpha-numeric parameter name. The values of these
         2565  +** In the templates above, NNN represents an integer literal,
         2566  +** and VVV represents an alphanumeric identifer.)^  ^The values of these
  2457   2567   ** parameters (also called "host parameter names" or "SQL parameters")
  2458   2568   ** can be set using the sqlite3_bind_*() routines defined here.
  2459   2569   **
  2460         -** The first argument to the sqlite3_bind_*() routines is always
         2570  +** ^The first argument to the sqlite3_bind_*() routines is always
  2461   2571   ** a pointer to the [sqlite3_stmt] object returned from
  2462   2572   ** [sqlite3_prepare_v2()] or its variants.
  2463   2573   **
  2464         -** The second argument is the index of the SQL parameter to be set.
  2465         -** The leftmost SQL parameter has an index of 1.  When the same named
         2574  +** ^The second argument is the index of the SQL parameter to be set.
         2575  +** ^The leftmost SQL parameter has an index of 1.  ^When the same named
  2466   2576   ** SQL parameter is used more than once, second and subsequent
  2467   2577   ** occurrences have the same index as the first occurrence.
  2468         -** The index for named parameters can be looked up using the
  2469         -** [sqlite3_bind_parameter_index()] API if desired.  The index
         2578  +** ^The index for named parameters can be looked up using the
         2579  +** [sqlite3_bind_parameter_index()] API if desired.  ^The index
  2470   2580   ** for "?NNN" parameters is the value of NNN.
  2471         -** The NNN value must be between 1 and the [sqlite3_limit()]
         2581  +** ^The NNN value must be between 1 and the [sqlite3_limit()]
  2472   2582   ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
  2473   2583   **
  2474         -** The third argument is the value to bind to the parameter.
         2584  +** ^The third argument is the value to bind to the parameter.
  2475   2585   **
  2476         -** In those routines that have a fourth argument, its value is the
         2586  +** ^(In those routines that have a fourth argument, its value is the
  2477   2587   ** number of bytes in the parameter.  To be clear: the value is the
  2478         -** number of <u>bytes</u> in the value, not the number of characters.
  2479         -** If the fourth parameter is negative, the length of the string is
         2588  +** number of <u>bytes</u> in the value, not the number of characters.)^
         2589  +** ^If the fourth parameter is negative, the length of the string is
  2480   2590   ** the number of bytes up to the first zero terminator.
  2481   2591   **
  2482         -** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
         2592  +** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
  2483   2593   ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
  2484         -** string after SQLite has finished with it. If the fifth argument is
         2594  +** string after SQLite has finished with it. ^If the fifth argument is
  2485   2595   ** the special value [SQLITE_STATIC], then SQLite assumes that the
  2486   2596   ** information is in static, unmanaged space and does not need to be freed.
  2487         -** If the fifth argument has the value [SQLITE_TRANSIENT], then
         2597  +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
  2488   2598   ** SQLite makes its own private copy of the data immediately, before
  2489   2599   ** the sqlite3_bind_*() routine returns.
  2490   2600   **
  2491         -** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
  2492         -** is filled with zeroes.  A zeroblob uses a fixed amount of memory
         2601  +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
         2602  +** is filled with zeroes.  ^A zeroblob uses a fixed amount of memory
  2493   2603   ** (just an integer to hold its size) while it is being processed.
  2494   2604   ** Zeroblobs are intended to serve as placeholders for BLOBs whose
  2495   2605   ** content is later written using
  2496   2606   ** [sqlite3_blob_open | incremental BLOB I/O] routines.
  2497         -** A negative value for the zeroblob results in a zero-length BLOB.
         2607  +** ^A negative value for the zeroblob results in a zero-length BLOB.
  2498   2608   **
  2499         -** The sqlite3_bind_*() routines must be called after
  2500         -** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and
  2501         -** before [sqlite3_step()].
  2502         -** Bindings are not cleared by the [sqlite3_reset()] routine.
  2503         -** Unbound parameters are interpreted as NULL.
         2609  +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer
         2610  +** for the [prepared statement] or with a prepared statement for which
         2611  +** [sqlite3_step()] has been called more recently than [sqlite3_reset()],
         2612  +** then the call will return [SQLITE_MISUSE].  If any sqlite3_bind_()
         2613  +** routine is passed a [prepared statement] that has been finalized, the
         2614  +** result is undefined and probably harmful.
  2504   2615   **
  2505         -** These routines return [SQLITE_OK] on success or an error code if
  2506         -** anything goes wrong.  [SQLITE_RANGE] is returned if the parameter
  2507         -** index is out of range.  [SQLITE_NOMEM] is returned if malloc() fails.
  2508         -** [SQLITE_MISUSE] might be returned if these routines are called on a
  2509         -** virtual machine that is the wrong state or which has already been finalized.
  2510         -** Detection of misuse is unreliable.  Applications should not depend
  2511         -** on SQLITE_MISUSE returns.  SQLITE_MISUSE is intended to indicate a
  2512         -** a logic error in the application.  Future versions of SQLite might
  2513         -** panic rather than return SQLITE_MISUSE.
         2616  +** ^Bindings are not cleared by the [sqlite3_reset()] routine.
         2617  +** ^Unbound parameters are interpreted as NULL.
         2618  +**
         2619  +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
         2620  +** [error code] if anything goes wrong.
         2621  +** ^[SQLITE_RANGE] is returned if the parameter
         2622  +** index is out of range.  ^[SQLITE_NOMEM] is returned if malloc() fails.
  2514   2623   **
  2515   2624   ** See also: [sqlite3_bind_parameter_count()],
  2516   2625   ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
  2517         -**
  2518         -** Requirements:
  2519         -** [H13506] [H13509] [H13512] [H13515] [H13518] [H13521] [H13524] [H13527]
  2520         -** [H13530] [H13533] [H13536] [H13539] [H13542] [H13545] [H13548] [H13551]
  2521         -**
  2522   2626   */
  2523         -int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
  2524         -int sqlite3_bind_double(sqlite3_stmt*, int, double);
  2525         -int sqlite3_bind_int(sqlite3_stmt*, int, int);
  2526         -int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
  2527         -int sqlite3_bind_null(sqlite3_stmt*, int);
  2528         -int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
  2529         -int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
  2530         -int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
  2531         -int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
         2627  +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
         2628  +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
         2629  +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
         2630  +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
         2631  +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
         2632  +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
         2633  +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
         2634  +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
         2635  +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
  2532   2636   
  2533   2637   /*
  2534         -** CAPI3REF: Number Of SQL Parameters {H13600} <S70300>
         2638  +** CAPI3REF: Number Of SQL Parameters
  2535   2639   **
  2536         -** This routine can be used to find the number of [SQL parameters]
         2640  +** ^This routine can be used to find the number of [SQL parameters]
  2537   2641   ** in a [prepared statement].  SQL parameters are tokens of the
  2538   2642   ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
  2539   2643   ** placeholders for values that are [sqlite3_bind_blob | bound]
  2540   2644   ** to the parameters at a later time.
  2541   2645   **
  2542         -** This routine actually returns the index of the largest (rightmost)
         2646  +** ^(This routine actually returns the index of the largest (rightmost)
  2543   2647   ** parameter. For all forms except ?NNN, this will correspond to the
  2544         -** number of unique parameters.  If parameters of the ?NNN are used,
  2545         -** there may be gaps in the list.
         2648  +** number of unique parameters.  If parameters of the ?NNN form are used,
         2649  +** there may be gaps in the list.)^
  2546   2650   **
  2547   2651   ** See also: [sqlite3_bind_blob|sqlite3_bind()],
  2548   2652   ** [sqlite3_bind_parameter_name()], and
  2549   2653   ** [sqlite3_bind_parameter_index()].
  2550         -**
  2551         -** Requirements:
  2552         -** [H13601]
  2553   2654   */
  2554         -int sqlite3_bind_parameter_count(sqlite3_stmt*);
         2655  +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
  2555   2656   
  2556   2657   /*
  2557         -** CAPI3REF: Name Of A Host Parameter {H13620} <S70300>
         2658  +** CAPI3REF: Name Of A Host Parameter
  2558   2659   **
  2559         -** This routine returns a pointer to the name of the n-th
  2560         -** [SQL parameter] in a [prepared statement].
  2561         -** SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
         2660  +** ^The sqlite3_bind_parameter_name(P,N) interface returns
         2661  +** the name of the N-th [SQL parameter] in the [prepared statement] P.
         2662  +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
  2562   2663   ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
  2563   2664   ** respectively.
  2564   2665   ** In other words, the initial ":" or "$" or "@" or "?"
  2565         -** is included as part of the name.
  2566         -** Parameters of the form "?" without a following integer have no name
  2567         -** and are also referred to as "anonymous parameters".
         2666  +** is included as part of the name.)^
         2667  +** ^Parameters of the form "?" without a following integer have no name
         2668  +** and are referred to as "nameless" or "anonymous parameters".
  2568   2669   **
  2569         -** The first host parameter has an index of 1, not 0.
         2670  +** ^The first host parameter has an index of 1, not 0.
  2570   2671   **
  2571         -** If the value n is out of range or if the n-th parameter is
  2572         -** nameless, then NULL is returned.  The returned string is
         2672  +** ^If the value N is out of range or if the N-th parameter is
         2673  +** nameless, then NULL is returned.  ^The returned string is
  2573   2674   ** always in UTF-8 encoding even if the named parameter was
  2574   2675   ** originally specified as UTF-16 in [sqlite3_prepare16()] or
  2575   2676   ** [sqlite3_prepare16_v2()].
  2576   2677   **
  2577   2678   ** See also: [sqlite3_bind_blob|sqlite3_bind()],
  2578   2679   ** [sqlite3_bind_parameter_count()], and
  2579   2680   ** [sqlite3_bind_parameter_index()].
  2580         -**
  2581         -** Requirements:
  2582         -** [H13621]
  2583   2681   */
  2584         -const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
         2682  +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
  2585   2683   
  2586   2684   /*
  2587         -** CAPI3REF: Index Of A Parameter With A Given Name {H13640} <S70300>
         2685  +** CAPI3REF: Index Of A Parameter With A Given Name
  2588   2686   **
  2589         -** Return the index of an SQL parameter given its name.  The
         2687  +** ^Return the index of an SQL parameter given its name.  ^The
  2590   2688   ** index value returned is suitable for use as the second
  2591         -** parameter to [sqlite3_bind_blob|sqlite3_bind()].  A zero
  2592         -** is returned if no matching parameter is found.  The parameter
         2689  +** parameter to [sqlite3_bind_blob|sqlite3_bind()].  ^A zero
         2690  +** is returned if no matching parameter is found.  ^The parameter
  2593   2691   ** name must be given in UTF-8 even if the original statement
  2594   2692   ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
  2595   2693   **
  2596   2694   ** See also: [sqlite3_bind_blob|sqlite3_bind()],
  2597   2695   ** [sqlite3_bind_parameter_count()], and
  2598   2696   ** [sqlite3_bind_parameter_index()].
  2599         -**
  2600         -** Requirements:
  2601         -** [H13641]
  2602   2697   */
  2603         -int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
         2698  +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
  2604   2699   
  2605   2700   /*
  2606         -** CAPI3REF: Reset All Bindings On A Prepared Statement {H13660} <S70300>
         2701  +** CAPI3REF: Reset All Bindings On A Prepared Statement
  2607   2702   **
  2608         -** Contrary to the intuition of many, [sqlite3_reset()] does not reset
         2703  +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
  2609   2704   ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
  2610         -** Use this routine to reset all host parameters to NULL.
  2611         -**
  2612         -** Requirements:
  2613         -** [H13661]
         2705  +** ^Use this routine to reset all host parameters to NULL.
  2614   2706   */
  2615         -int sqlite3_clear_bindings(sqlite3_stmt*);
         2707  +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
  2616   2708   
  2617   2709   /*
  2618         -** CAPI3REF: Number Of Columns In A Result Set {H13710} <S10700>
         2710  +** CAPI3REF: Number Of Columns In A Result Set
  2619   2711   **
  2620         -** Return the number of columns in the result set returned by the
  2621         -** [prepared statement]. This routine returns 0 if pStmt is an SQL
         2712  +** ^Return the number of columns in the result set returned by the
         2713  +** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
  2622   2714   ** statement that does not return data (for example an [UPDATE]).
  2623         -**
  2624         -** Requirements:
  2625         -** [H13711]
  2626   2715   */
  2627         -int sqlite3_column_count(sqlite3_stmt *pStmt);
         2716  +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
  2628   2717   
  2629   2718   /*
  2630         -** CAPI3REF: Column Names In A Result Set {H13720} <S10700>
         2719  +** CAPI3REF: Column Names In A Result Set
  2631   2720   **
  2632         -** These routines return the name assigned to a particular column
  2633         -** in the result set of a [SELECT] statement.  The sqlite3_column_name()
         2721  +** ^These routines return the name assigned to a particular column
         2722  +** in the result set of a [SELECT] statement.  ^The sqlite3_column_name()
  2634   2723   ** interface returns a pointer to a zero-terminated UTF-8 string
  2635   2724   ** and sqlite3_column_name16() returns a pointer to a zero-terminated
  2636         -** UTF-16 string.  The first parameter is the [prepared statement]
  2637         -** that implements the [SELECT] statement. The second parameter is the
  2638         -** column number.  The leftmost column is number 0.
         2725  +** UTF-16 string.  ^The first parameter is the [prepared statement]
         2726  +** that implements the [SELECT] statement. ^The second parameter is the
         2727  +** column number.  ^The leftmost column is number 0.
  2639   2728   **
  2640         -** The returned string pointer is valid until either the [prepared statement]
         2729  +** ^The returned string pointer is valid until either the [prepared statement]
  2641   2730   ** is destroyed by [sqlite3_finalize()] or until the next call to
  2642   2731   ** sqlite3_column_name() or sqlite3_column_name16() on the same column.
  2643   2732   **
  2644         -** If sqlite3_malloc() fails during the processing of either routine
         2733  +** ^If sqlite3_malloc() fails during the processing of either routine
  2645   2734   ** (for example during a conversion from UTF-8 to UTF-16) then a
  2646   2735   ** NULL pointer is returned.
  2647   2736   **
  2648         -** The name of a result column is the value of the "AS" clause for
         2737  +** ^The name of a result column is the value of the "AS" clause for
  2649   2738   ** that column, if there is an AS clause.  If there is no AS clause
  2650   2739   ** then the name of the column is unspecified and may change from
  2651   2740   ** one release of SQLite to the next.
  2652         -**
  2653         -** Requirements:
  2654         -** [H13721] [H13723] [H13724] [H13725] [H13726] [H13727]
  2655   2741   */
  2656         -const char *sqlite3_column_name(sqlite3_stmt*, int N);
  2657         -const void *sqlite3_column_name16(sqlite3_stmt*, int N);
         2742  +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
         2743  +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
  2658   2744   
  2659   2745   /*
  2660         -** CAPI3REF: Source Of Data In A Query Result {H13740} <S10700>
         2746  +** CAPI3REF: Source Of Data In A Query Result
  2661   2747   **
  2662         -** These routines provide a means to determine what column of what
  2663         -** table in which database a result of a [SELECT] statement comes from.
  2664         -** The name of the database or table or column can be returned as
  2665         -** either a UTF-8 or UTF-16 string.  The _database_ routines return
         2748  +** ^These routines provide a means to determine the database, table, and
         2749  +** table column that is the origin of a particular result column in
         2750  +** [SELECT] statement.
         2751  +** ^The name of the database or table or column can be returned as
         2752  +** either a UTF-8 or UTF-16 string.  ^The _database_ routines return
  2666   2753   ** the database name, the _table_ routines return the table name, and
  2667   2754   ** the origin_ routines return the column name.
  2668         -** The returned string is valid until the [prepared statement] is destroyed
         2755  +** ^The returned string is valid until the [prepared statement] is destroyed
  2669   2756   ** using [sqlite3_finalize()] or until the same information is requested
  2670   2757   ** again in a different encoding.
  2671   2758   **
  2672         -** The names returned are the original un-aliased names of the
         2759  +** ^The names returned are the original un-aliased names of the
  2673   2760   ** database, table, and column.
  2674   2761   **
  2675         -** The first argument to the following calls is a [prepared statement].
  2676         -** These functions return information about the Nth column returned by
         2762  +** ^The first argument to these interfaces is a [prepared statement].
         2763  +** ^These functions return information about the Nth result column returned by
  2677   2764   ** the statement, where N is the second function argument.
         2765  +** ^The left-most column is column 0 for these routines.
  2678   2766   **
  2679         -** If the Nth column returned by the statement is an expression or
         2767  +** ^If the Nth column returned by the statement is an expression or
  2680   2768   ** subquery and is not a column value, then all of these functions return
  2681         -** NULL.  These routine might also return NULL if a memory allocation error
  2682         -** occurs.  Otherwise, they return the name of the attached database, table
  2683         -** and column that query result column was extracted from.
         2769  +** NULL.  ^These routine might also return NULL if a memory allocation error
         2770  +** occurs.  ^Otherwise, they return the name of the attached database, table,
         2771  +** or column that query result column was extracted from.
  2684   2772   **
  2685         -** As with all other SQLite APIs, those postfixed with "16" return
  2686         -** UTF-16 encoded strings, the other functions return UTF-8. {END}
         2773  +** ^As with all other SQLite APIs, those whose names end with "16" return
         2774  +** UTF-16 encoded strings and the other functions return UTF-8.
  2687   2775   **
  2688         -** These APIs are only available if the library was compiled with the
  2689         -** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
         2776  +** ^These APIs are only available if the library was compiled with the
         2777  +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
  2690   2778   **
  2691         -** {A13751}
  2692   2779   ** If two or more threads call one or more of these routines against the same
  2693   2780   ** prepared statement and column at the same time then the results are
  2694   2781   ** undefined.
  2695   2782   **
  2696         -** Requirements:
  2697         -** [H13741] [H13742] [H13743] [H13744] [H13745] [H13746] [H13748]
  2698         -**
  2699   2783   ** If two or more threads call one or more
  2700   2784   ** [sqlite3_column_database_name | column metadata interfaces]
  2701   2785   ** for the same [prepared statement] and result column
  2702   2786   ** at the same time then the results are undefined.
  2703   2787   */
  2704         -const char *sqlite3_column_database_name(sqlite3_stmt*,int);
  2705         -const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
  2706         -const char *sqlite3_column_table_name(sqlite3_stmt*,int);
  2707         -const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
  2708         -const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
  2709         -const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
         2788  +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
         2789  +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
         2790  +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
         2791  +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
         2792  +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
         2793  +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
  2710   2794   
  2711   2795   /*
  2712         -** CAPI3REF: Declared Datatype Of A Query Result {H13760} <S10700>
         2796  +** CAPI3REF: Declared Datatype Of A Query Result
  2713   2797   **
  2714         -** The first parameter is a [prepared statement].
         2798  +** ^(The first parameter is a [prepared statement].
  2715   2799   ** If this statement is a [SELECT] statement and the Nth column of the
  2716   2800   ** returned result set of that [SELECT] is a table column (not an
  2717   2801   ** expression or subquery) then the declared type of the table
  2718         -** column is returned.  If the Nth column of the result set is an
         2802  +** column is returned.)^  ^If the Nth column of the result set is an
  2719   2803   ** expression or subquery, then a NULL pointer is returned.
  2720         -** The returned string is always UTF-8 encoded. {END}
         2804  +** ^The returned string is always UTF-8 encoded.
  2721   2805   **
  2722         -** For example, given the database schema:
         2806  +** ^(For example, given the database schema:
  2723   2807   **
  2724   2808   ** CREATE TABLE t1(c1 VARIANT);
  2725   2809   **
  2726   2810   ** and the following statement to be compiled:
  2727   2811   **
  2728   2812   ** SELECT c1 + 1, c1 FROM t1;
  2729   2813   **
  2730   2814   ** this routine would return the string "VARIANT" for the second result
  2731         -** column (i==1), and a NULL pointer for the first result column (i==0).
         2815  +** column (i==1), and a NULL pointer for the first result column (i==0).)^
  2732   2816   **
  2733         -** SQLite uses dynamic run-time typing.  So just because a column
         2817  +** ^SQLite uses dynamic run-time typing.  ^So just because a column
  2734   2818   ** is declared to contain a particular type does not mean that the
  2735   2819   ** data stored in that column is of the declared type.  SQLite is
  2736         -** strongly typed, but the typing is dynamic not static.  Type
         2820  +** strongly typed, but the typing is dynamic not static.  ^Type
  2737   2821   ** is associated with individual values, not with the containers
  2738   2822   ** used to hold those values.
  2739         -**
  2740         -** Requirements:
  2741         -** [H13761] [H13762] [H13763]
  2742   2823   */
  2743         -const char *sqlite3_column_decltype(sqlite3_stmt*,int);
  2744         -const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
         2824  +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
         2825  +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
  2745   2826   
  2746   2827   /*
  2747         -** CAPI3REF: Evaluate An SQL Statement {H13200} <S10000>
         2828  +** CAPI3REF: Evaluate An SQL Statement
  2748   2829   **
  2749   2830   ** After a [prepared statement] has been prepared using either
  2750   2831   ** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
  2751   2832   ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
  2752   2833   ** must be called one or more times to evaluate the statement.
  2753   2834   **
  2754   2835   ** The details of the behavior of the sqlite3_step() interface depend
  2755   2836   ** on whether the statement was prepared using the newer "v2" interface
  2756   2837   ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
  2757   2838   ** interface [sqlite3_prepare()] and [sqlite3_prepare16()].  The use of the
  2758   2839   ** new "v2" interface is recommended for new applications but the legacy
  2759   2840   ** interface will continue to be supported.
  2760   2841   **
  2761         -** In the legacy interface, the return value will be either [SQLITE_BUSY],
         2842  +** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
  2762   2843   ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
  2763         -** With the "v2" interface, any of the other [result codes] or
         2844  +** ^With the "v2" interface, any of the other [result codes] or
  2764   2845   ** [extended result codes] might be returned as well.
  2765   2846   **
  2766         -** [SQLITE_BUSY] means that the database engine was unable to acquire the
  2767         -** database locks it needs to do its job.  If the statement is a [COMMIT]
         2847  +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the
         2848  +** database locks it needs to do its job.  ^If the statement is a [COMMIT]
  2768   2849   ** or occurs outside of an explicit transaction, then you can retry the
  2769   2850   ** statement.  If the statement is not a [COMMIT] and occurs within a
  2770   2851   ** explicit transaction then you should rollback the transaction before
  2771   2852   ** continuing.
  2772   2853   **
  2773         -** [SQLITE_DONE] means that the statement has finished executing
         2854  +** ^[SQLITE_DONE] means that the statement has finished executing
  2774   2855   ** successfully.  sqlite3_step() should not be called again on this virtual
  2775   2856   ** machine without first calling [sqlite3_reset()] to reset the virtual
  2776   2857   ** machine back to its initial state.
  2777   2858   **
  2778         -** If the SQL statement being executed returns any data, then [SQLITE_ROW]
         2859  +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
  2779   2860   ** is returned each time a new row of data is ready for processing by the
  2780   2861   ** caller. The values may be accessed using the [column access functions].
  2781   2862   ** sqlite3_step() is called again to retrieve the next row of data.
  2782   2863   **
  2783         -** [SQLITE_ERROR] means that a run-time error (such as a constraint
         2864  +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
  2784   2865   ** violation) has occurred.  sqlite3_step() should not be called again on
  2785   2866   ** the VM. More information may be found by calling [sqlite3_errmsg()].
  2786         -** With the legacy interface, a more specific error code (for example,
         2867  +** ^With the legacy interface, a more specific error code (for example,
  2787   2868   ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
  2788   2869   ** can be obtained by calling [sqlite3_reset()] on the
  2789         -** [prepared statement].  In the "v2" interface,
         2870  +** [prepared statement].  ^In the "v2" interface,
  2790   2871   ** the more specific error code is returned directly by sqlite3_step().
  2791   2872   **
  2792   2873   ** [SQLITE_MISUSE] means that the this routine was called inappropriately.
  2793   2874   ** Perhaps it was called on a [prepared statement] that has
  2794   2875   ** already been [sqlite3_finalize | finalized] or on one that had
  2795   2876   ** previously returned [SQLITE_ERROR] or [SQLITE_DONE].  Or it could
  2796   2877   ** be the case that the same database connection is being used by two or
................................................................................
  2803   2884   ** specific [error codes] that better describes the error.
  2804   2885   ** We admit that this is a goofy design.  The problem has been fixed
  2805   2886   ** with the "v2" interface.  If you prepare all of your SQL statements
  2806   2887   ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
  2807   2888   ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
  2808   2889   ** then the more specific [error codes] are returned directly
  2809   2890   ** by sqlite3_step().  The use of the "v2" interface is recommended.
  2810         -**
  2811         -** Requirements:
  2812         -** [H13202] [H15304] [H15306] [H15308] [H15310]
  2813   2891   */
  2814         -int sqlite3_step(sqlite3_stmt*);
         2892  +SQLITE_API int sqlite3_step(sqlite3_stmt*);
  2815   2893   
  2816   2894   /*
  2817         -** CAPI3REF: Number of columns in a result set {H13770} <S10700>
         2895  +** CAPI3REF: Number of columns in a result set
  2818   2896   **
  2819         -** Returns the number of values in the current row of the result set.
  2820         -**
  2821         -** Requirements:
  2822         -** [H13771] [H13772]
         2897  +** ^The sqlite3_data_count(P) the number of columns in the
         2898  +** of the result set of [prepared statement] P.
  2823   2899   */
  2824         -int sqlite3_data_count(sqlite3_stmt *pStmt);
         2900  +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
  2825   2901   
  2826   2902   /*
  2827         -** CAPI3REF: Fundamental Datatypes {H10265} <S10110><S10120>
         2903  +** CAPI3REF: Fundamental Datatypes
  2828   2904   ** KEYWORDS: SQLITE_TEXT
  2829   2905   **
  2830         -** {H10266} Every value in SQLite has one of five fundamental datatypes:
         2906  +** ^(Every value in SQLite has one of five fundamental datatypes:
  2831   2907   **
  2832   2908   ** <ul>
  2833   2909   ** <li> 64-bit signed integer
  2834   2910   ** <li> 64-bit IEEE floating point number
  2835   2911   ** <li> string
  2836   2912   ** <li> BLOB
  2837   2913   ** <li> NULL
  2838         -** </ul> {END}
         2914  +** </ul>)^
  2839   2915   **
  2840   2916   ** These constants are codes for each of those types.
  2841   2917   **
  2842   2918   ** Note that the SQLITE_TEXT constant was also used in SQLite version 2
  2843   2919   ** for a completely different meaning.  Software that links against both
  2844   2920   ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
  2845   2921   ** SQLITE_TEXT.
................................................................................
  2852   2928   # undef SQLITE_TEXT
  2853   2929   #else
  2854   2930   # define SQLITE_TEXT     3
  2855   2931   #endif
  2856   2932   #define SQLITE3_TEXT     3
  2857   2933   
  2858   2934   /*
  2859         -** CAPI3REF: Result Values From A Query {H13800} <S10700>
         2935  +** CAPI3REF: Result Values From A Query
  2860   2936   ** KEYWORDS: {column access functions}
  2861   2937   **
  2862         -** These routines form the "result set query" interface.
         2938  +** These routines form the "result set" interface.
  2863   2939   **
  2864         -** These routines return information about a single column of the current
  2865         -** result row of a query.  In every case the first argument is a pointer
         2940  +** ^These routines return information about a single column of the current
         2941  +** result row of a query.  ^In every case the first argument is a pointer
  2866   2942   ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
  2867   2943   ** that was returned from [sqlite3_prepare_v2()] or one of its variants)
  2868   2944   ** and the second argument is the index of the column for which information
  2869         -** should be returned.  The leftmost column of the result set has the index 0.
         2945  +** should be returned. ^The leftmost column of the result set has the index 0.
         2946  +** ^The number of columns in the result can be determined using
         2947  +** [sqlite3_column_count()].
  2870   2948   **
  2871   2949   ** If the SQL statement does not currently point to a valid row, or if the
  2872   2950   ** column index is out of range, the result is undefined.
  2873   2951   ** These routines may only be called when the most recent call to
  2874   2952   ** [sqlite3_step()] has returned [SQLITE_ROW] and neither
  2875   2953   ** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
  2876   2954   ** If any of these routines are called after [sqlite3_reset()] or
  2877   2955   ** [sqlite3_finalize()] or after [sqlite3_step()] has returned
  2878   2956   ** something other than [SQLITE_ROW], the results are undefined.
  2879   2957   ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
  2880   2958   ** are called from a different thread while any of these routines
  2881   2959   ** are pending, then the results are undefined.
  2882   2960   **
  2883         -** The sqlite3_column_type() routine returns the
         2961  +** ^The sqlite3_column_type() routine returns the
  2884   2962   ** [SQLITE_INTEGER | datatype code] for the initial data type
  2885         -** of the result column.  The returned value is one of [SQLITE_INTEGER],
         2963  +** of the result column.  ^The returned value is one of [SQLITE_INTEGER],
  2886   2964   ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].  The value
  2887   2965   ** returned by sqlite3_column_type() is only meaningful if no type
  2888   2966   ** conversions have occurred as described below.  After a type conversion,
  2889   2967   ** the value returned by sqlite3_column_type() is undefined.  Future
  2890   2968   ** versions of SQLite may change the behavior of sqlite3_column_type()
  2891   2969   ** following a type conversion.
  2892   2970   **
  2893         -** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
         2971  +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
  2894   2972   ** routine returns the number of bytes in that BLOB or string.
  2895         -** If the result is a UTF-16 string, then sqlite3_column_bytes() converts
         2973  +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
  2896   2974   ** the string to UTF-8 and then returns the number of bytes.
  2897         -** If the result is a numeric value then sqlite3_column_bytes() uses
         2975  +** ^If the result is a numeric value then sqlite3_column_bytes() uses
  2898   2976   ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
  2899   2977   ** the number of bytes in that string.
  2900         -** The value returned does not include the zero terminator at the end
  2901         -** of the string.  For clarity: the value returned is the number of
         2978  +** ^The value returned does not include the zero terminator at the end
         2979  +** of the string.  ^For clarity: the value returned is the number of
  2902   2980   ** bytes in the string, not the number of characters.
  2903   2981   **
  2904         -** Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
  2905         -** even empty strings, are always zero terminated.  The return
         2982  +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
         2983  +** even empty strings, are always zero terminated.  ^The return
  2906   2984   ** value from sqlite3_column_blob() for a zero-length BLOB is an arbitrary
  2907   2985   ** pointer, possibly even a NULL pointer.
  2908   2986   **
  2909         -** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
         2987  +** ^The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes()
  2910   2988   ** but leaves the result in UTF-16 in native byte order instead of UTF-8.
  2911         -** The zero terminator is not included in this count.
         2989  +** ^The zero terminator is not included in this count.
  2912   2990   **
  2913         -** The object returned by [sqlite3_column_value()] is an
         2991  +** ^The object returned by [sqlite3_column_value()] is an
  2914   2992   ** [unprotected sqlite3_value] object.  An unprotected sqlite3_value object
  2915   2993   ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()].
  2916   2994   ** If the [unprotected sqlite3_value] object returned by
  2917   2995   ** [sqlite3_column_value()] is used in any other way, including calls
  2918   2996   ** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
  2919   2997   ** or [sqlite3_value_bytes()], then the behavior is undefined.
  2920   2998   **
  2921         -** These routines attempt to convert the value where appropriate.  For
         2999  +** These routines attempt to convert the value where appropriate.  ^For
  2922   3000   ** example, if the internal representation is FLOAT and a text result
  2923   3001   ** is requested, [sqlite3_snprintf()] is used internally to perform the
  2924         -** conversion automatically.  The following table details the conversions
         3002  +** conversion automatically.  ^(The following table details the conversions
  2925   3003   ** that are applied:
  2926   3004   **
  2927   3005   ** <blockquote>
  2928   3006   ** <table border="1">
  2929   3007   ** <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
  2930   3008   **
  2931   3009   ** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
................................................................................
  2941   3019   ** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
  2942   3020   ** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
  2943   3021   ** <tr><td>  TEXT    <td>   BLOB    <td> No change
  2944   3022   ** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
  2945   3023   ** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
  2946   3024   ** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
  2947   3025   ** </table>
  2948         -** </blockquote>
         3026  +** </blockquote>)^
  2949   3027   **
  2950   3028   ** The table above makes reference to standard C library functions atoi()
  2951   3029   ** and atof().  SQLite does not really use these functions.  It has its
  2952   3030   ** own equivalent internal routines.  The atoi() and atof() names are
  2953   3031   ** used in the table for brevity and because they are familiar to most
  2954   3032   ** C programmers.
  2955   3033   **
  2956         -** Note that when type conversions occur, pointers returned by prior
         3034  +** ^Note that when type conversions occur, pointers returned by prior
  2957   3035   ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
  2958   3036   ** sqlite3_column_text16() may be invalidated.
  2959         -** Type conversions and pointer invalidations might occur
         3037  +** ^(Type conversions and pointer invalidations might occur
  2960   3038   ** in the following cases:
  2961   3039   **
  2962   3040   ** <ul>
  2963   3041   ** <li> The initial content is a BLOB and sqlite3_column_text() or
  2964   3042   **      sqlite3_column_text16() is called.  A zero-terminator might
  2965   3043   **      need to be added to the string.</li>
  2966   3044   ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
  2967   3045   **      sqlite3_column_text16() is called.  The content must be converted
  2968   3046   **      to UTF-16.</li>
  2969   3047   ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
  2970   3048   **      sqlite3_column_text() is called.  The content must be converted
  2971   3049   **      to UTF-8.</li>
  2972         -** </ul>
         3050  +** </ul>)^
  2973   3051   **
  2974         -** Conversions between UTF-16be and UTF-16le are always done in place and do
         3052  +** ^Conversions between UTF-16be and UTF-16le are always done in place and do
  2975   3053   ** not invalidate a prior pointer, though of course the content of the buffer
  2976   3054   ** that the prior pointer points to will have been modified.  Other kinds
  2977   3055   ** of conversion are done in place when it is possible, but sometimes they
  2978   3056   ** are not possible and in those cases prior pointers are invalidated.
  2979   3057   **
  2980         -** The safest and easiest to remember policy is to invoke these routines
         3058  +** ^(The safest and easiest to remember policy is to invoke these routines
  2981   3059   ** in one of the following ways:
  2982   3060   **
  2983   3061   ** <ul>
  2984   3062   **  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
  2985   3063   **  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
  2986   3064   **  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
  2987         -** </ul>
         3065  +** </ul>)^
  2988   3066   **
  2989   3067   ** In other words, you should call sqlite3_column_text(),
  2990   3068   ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
  2991   3069   ** into the desired format, then invoke sqlite3_column_bytes() or
  2992   3070   ** sqlite3_column_bytes16() to find the size of the result.  Do not mix calls
  2993   3071   ** to sqlite3_column_text() or sqlite3_column_blob() with calls to
  2994   3072   ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
  2995   3073   ** with calls to sqlite3_column_bytes().
  2996   3074   **
  2997         -** The pointers returned are valid until a type conversion occurs as
         3075  +** ^The pointers returned are valid until a type conversion occurs as
  2998   3076   ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
  2999         -** [sqlite3_finalize()] is called.  The memory space used to hold strings
         3077  +** [sqlite3_finalize()] is called.  ^The memory space used to hold strings
  3000   3078   ** and BLOBs is freed automatically.  Do <b>not</b> pass the pointers returned
  3001   3079   ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
  3002   3080   ** [sqlite3_free()].
  3003   3081   **
  3004         -** If a memory allocation error occurs during the evaluation of any
         3082  +** ^(If a memory allocation error occurs during the evaluation of any
  3005   3083   ** of these routines, a default value is returned.  The default value
  3006   3084   ** is either the integer 0, the floating point number 0.0, or a NULL
  3007   3085   ** pointer.  Subsequent calls to [sqlite3_errcode()] will return
  3008         -** [SQLITE_NOMEM].
  3009         -**
  3010         -** Requirements:
  3011         -** [H13803] [H13806] [H13809] [H13812] [H13815] [H13818] [H13821] [H13824]
  3012         -** [H13827] [H13830]
  3013         -*/
  3014         -const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
  3015         -int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
  3016         -int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
  3017         -double sqlite3_column_double(sqlite3_stmt*, int iCol);
  3018         -int sqlite3_column_int(sqlite3_stmt*, int iCol);
  3019         -sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
  3020         -const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
  3021         -const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
  3022         -int sqlite3_column_type(sqlite3_stmt*, int iCol);
  3023         -sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
  3024         -
  3025         -/*
  3026         -** CAPI3REF: Destroy A Prepared Statement Object {H13300} <S70300><S30100>
  3027         -**
  3028         -** The sqlite3_finalize() function is called to delete a [prepared statement].
  3029         -** If the statement was executed successfully or not executed at all, then
  3030         -** SQLITE_OK is returned. If execution of the statement failed then an
         3086  +** [SQLITE_NOMEM].)^
         3087  +*/
         3088  +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
         3089  +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
         3090  +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
         3091  +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
         3092  +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
         3093  +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
         3094  +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
         3095  +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
         3096  +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
         3097  +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
         3098  +
         3099  +/*
         3100  +** CAPI3REF: Destroy A Prepared Statement Object
         3101  +**
         3102  +** ^The sqlite3_finalize() function is called to delete a [prepared statement].
         3103  +** ^If the statement was executed successfully or not executed at all, then
         3104  +** SQLITE_OK is returned. ^If execution of the statement failed then an
  3031   3105   ** [error code] or [extended error code] is returned.
  3032   3106   **
  3033         -** This routine can be called at any point during the execution of the
  3034         -** [prepared statement].  If the virtual machine has not
         3107  +** ^This routine can be called at any point during the execution of the
         3108  +** [prepared statement].  ^If the virtual machine has not
  3035   3109   ** completed execution when this routine is called, that is like
  3036   3110   ** encountering an error or an [sqlite3_interrupt | interrupt].
  3037         -** Incomplete updates may be rolled back and transactions canceled,
         3111  +** ^Incomplete updates may be rolled back and transactions canceled,
  3038   3112   ** depending on the circumstances, and the
  3039   3113   ** [error code] returned will be [SQLITE_ABORT].
  3040         -**
  3041         -** Requirements:
  3042         -** [H11302] [H11304]
  3043   3114   */
  3044         -int sqlite3_finalize(sqlite3_stmt *pStmt);
         3115  +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
  3045   3116   
  3046   3117   /*
  3047         -** CAPI3REF: Reset A Prepared Statement Object {H13330} <S70300>
         3118  +** CAPI3REF: Reset A Prepared Statement Object
  3048   3119   **
  3049   3120   ** The sqlite3_reset() function is called to reset a [prepared statement]
  3050   3121   ** object back to its initial state, ready to be re-executed.
  3051         -** Any SQL statement variables that had values bound to them using
         3122  +** ^Any SQL statement variables that had values bound to them using
  3052   3123   ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
  3053   3124   ** Use [sqlite3_clear_bindings()] to reset the bindings.
  3054   3125   **
  3055         -** {H11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S
  3056         -**          back to the beginning of its program.
         3126  +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S
         3127  +** back to the beginning of its program.
  3057   3128   **
  3058         -** {H11334} If the most recent call to [sqlite3_step(S)] for the
  3059         -**          [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
  3060         -**          or if [sqlite3_step(S)] has never before been called on S,
  3061         -**          then [sqlite3_reset(S)] returns [SQLITE_OK].
         3129  +** ^If the most recent call to [sqlite3_step(S)] for the
         3130  +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
         3131  +** or if [sqlite3_step(S)] has never before been called on S,
         3132  +** then [sqlite3_reset(S)] returns [SQLITE_OK].
  3062   3133   **
  3063         -** {H11336} If the most recent call to [sqlite3_step(S)] for the
  3064         -**          [prepared statement] S indicated an error, then
  3065         -**          [sqlite3_reset(S)] returns an appropriate [error code].
         3134  +** ^If the most recent call to [sqlite3_step(S)] for the
         3135  +** [prepared statement] S indicated an error, then
         3136  +** [sqlite3_reset(S)] returns an appropriate [error code].
  3066   3137   **
  3067         -** {H11338} The [sqlite3_reset(S)] interface does not change the values
  3068         -**          of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
         3138  +** ^The [sqlite3_reset(S)] interface does not change the values
         3139  +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
  3069   3140   */
  3070         -int sqlite3_reset(sqlite3_stmt *pStmt);
         3141  +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
  3071   3142   
  3072   3143   /*
  3073         -** CAPI3REF: Create Or Redefine SQL Functions {H16100} <S20200>
         3144  +** CAPI3REF: Create Or Redefine SQL Functions
  3074   3145   ** KEYWORDS: {function creation routines}
  3075   3146   ** KEYWORDS: {application-defined SQL function}
  3076   3147   ** KEYWORDS: {application-defined SQL functions}
  3077   3148   **
  3078         -** These two functions (collectively known as "function creation routines")
         3149  +** ^These two functions (collectively known as "function creation routines")
  3079   3150   ** are used to add SQL functions or aggregates or to redefine the behavior
  3080   3151   ** of existing SQL functions or aggregates.  The only difference between the
  3081   3152   ** two is that the second parameter, the name of the (scalar) function or
  3082   3153   ** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16
  3083   3154   ** for sqlite3_create_function16().
  3084   3155   **
  3085         -** The first parameter is the [database connection] to which the SQL
  3086         -** function is to be added.  If a single program uses more than one database
  3087         -** connection internally, then SQL functions must be added individually to
  3088         -** each database connection.
         3156  +** ^The first parameter is the [database connection] to which the SQL
         3157  +** function is to be added.  ^If an application uses more than one database
         3158  +** connection then application-defined SQL functions must be added
         3159  +** to each database connection separately.
  3089   3160   **
  3090   3161   ** The second parameter is the name of the SQL function to be created or
  3091         -** redefined.  The length of the name is limited to 255 bytes, exclusive of
         3162  +** redefined.  ^The length of the name is limited to 255 bytes, exclusive of
  3092   3163   ** the zero-terminator.  Note that the name length limit is in bytes, not
  3093         -** characters.  Any attempt to create a function with a longer name
         3164  +** characters.  ^Any attempt to create a function with a longer name
  3094   3165   ** will result in [SQLITE_ERROR] being returned.
  3095   3166   **
  3096         -** The third parameter (nArg)
         3167  +** ^The third parameter (nArg)
  3097   3168   ** is the number of arguments that the SQL function or
  3098         -** aggregate takes. If this parameter is -1, then the SQL function or
         3169  +** aggregate takes. ^If this parameter is -1, then the SQL function or
  3099   3170   ** aggregate may take any number of arguments between 0 and the limit
  3100   3171   ** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]).  If the third
  3101   3172   ** parameter is less than -1 or greater than 127 then the behavior is
  3102   3173   ** undefined.
  3103   3174   **
  3104   3175   ** The fourth parameter, eTextRep, specifies what
  3105   3176   ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
  3106   3177   ** its parameters.  Any SQL function implementation should be able to work
  3107   3178   ** work with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
  3108         -** more efficient with one encoding than another.  It is allowed to
         3179  +** more efficient with one encoding than another.  ^An application may
  3109   3180   ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
  3110   3181   ** times with the same function but with different values of eTextRep.
  3111         -** When multiple implementations of the same function are available, SQLite
         3182  +** ^When multiple implementations of the same function are available, SQLite
  3112   3183   ** will pick the one that involves the least amount of data conversion.
  3113   3184   ** If there is only a single implementation which does not care what text
  3114   3185   ** encoding is used, then the fourth argument should be [SQLITE_ANY].
  3115   3186   **
  3116         -** The fifth parameter is an arbitrary pointer.  The implementation of the
  3117         -** function can gain access to this pointer using [sqlite3_user_data()].
         3187  +** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
         3188  +** function can gain access to this pointer using [sqlite3_user_data()].)^
  3118   3189   **
  3119   3190   ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are
  3120   3191   ** pointers to C-language functions that implement the SQL function or
  3121         -** aggregate. A scalar SQL function requires an implementation of the xFunc
  3122         -** callback only, NULL pointers should be passed as the xStep and xFinal
  3123         -** parameters. An aggregate SQL function requires an implementation of xStep
  3124         -** and xFinal and NULL should be passed for xFunc. To delete an existing
         3192  +** aggregate. ^A scalar SQL function requires an implementation of the xFunc
         3193  +** callback only; NULL pointers should be passed as the xStep and xFinal
         3194  +** parameters. ^An aggregate SQL function requires an implementation of xStep
         3195  +** and xFinal and NULL should be passed for xFunc. ^To delete an existing
  3125   3196   ** SQL function or aggregate, pass NULL for all three function callbacks.
  3126   3197   **
  3127         -** It is permitted to register multiple implementations of the same
         3198  +** ^It is permitted to register multiple implementations of the same
  3128   3199   ** functions with the same name but with either differing numbers of
  3129         -** arguments or differing preferred text encodings.  SQLite will use
  3130         -** the implementation most closely matches the way in which the
  3131         -** SQL function is used.  A function implementation with a non-negative
         3200  +** arguments or differing preferred text encodings.  ^SQLite will use
         3201  +** the implementation that most closely matches the way in which the
         3202  +** SQL function is used.  ^A function implementation with a non-negative
  3132   3203   ** nArg parameter is a better match than a function implementation with
  3133         -** a negative nArg.  A function where the preferred text encoding
         3204  +** a negative nArg.  ^A function where the preferred text encoding
  3134   3205   ** matches the database encoding is a better
  3135   3206   ** match than a function where the encoding is different.  
  3136         -** A function where the encoding difference is between UTF16le and UTF16be
         3207  +** ^A function where the encoding difference is between UTF16le and UTF16be
  3137   3208   ** is a closer match than a function where the encoding difference is
  3138   3209   ** between UTF8 and UTF16.
  3139   3210   **
  3140         -** Built-in functions may be overloaded by new application-defined functions.
  3141         -** The first application-defined function with a given name overrides all
         3211  +** ^Built-in functions may be overloaded by new application-defined functions.
         3212  +** ^The first application-defined function with a given name overrides all
  3142   3213   ** built-in functions in the same [database connection] with the same name.
  3143         -** Subsequent application-defined functions of the same name only override 
         3214  +** ^Subsequent application-defined functions of the same name only override 
  3144   3215   ** prior application-defined functions that are an exact match for the
  3145   3216   ** number of parameters and preferred encoding.
  3146   3217   **
  3147         -** An application-defined function is permitted to call other
         3218  +** ^An application-defined function is permitted to call other
  3148   3219   ** SQLite interfaces.  However, such calls must not
  3149   3220   ** close the database connection nor finalize or reset the prepared
  3150   3221   ** statement in which the function is running.
  3151         -**
  3152         -** Requirements:
  3153         -** [H16103] [H16106] [H16109] [H16112] [H16118] [H16121] [H16127]
  3154         -** [H16130] [H16133] [H16136] [H16139] [H16142]
  3155   3222   */
  3156         -int sqlite3_create_function(
         3223  +SQLITE_API int sqlite3_create_function(
  3157   3224     sqlite3 *db,
  3158   3225     const char *zFunctionName,
  3159   3226     int nArg,
  3160   3227     int eTextRep,
  3161   3228     void *pApp,
  3162   3229     void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  3163   3230     void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  3164   3231     void (*xFinal)(sqlite3_context*)
  3165   3232   );
  3166         -int sqlite3_create_function16(
         3233  +SQLITE_API int sqlite3_create_function16(
  3167   3234     sqlite3 *db,
  3168   3235     const void *zFunctionName,
  3169   3236     int nArg,
  3170   3237     int eTextRep,
  3171   3238     void *pApp,
  3172   3239     void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  3173   3240     void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  3174   3241     void (*xFinal)(sqlite3_context*)
  3175   3242   );
  3176   3243   
  3177   3244   /*
  3178         -** CAPI3REF: Text Encodings {H10267} <S50200> <H16100>
         3245  +** CAPI3REF: Text Encodings
  3179   3246   **
  3180   3247   ** These constant define integer codes that represent the various
  3181   3248   ** text encodings supported by SQLite.
  3182   3249   */
  3183   3250   #define SQLITE_UTF8           1
  3184   3251   #define SQLITE_UTF16LE        2
  3185   3252   #define SQLITE_UTF16BE        3
................................................................................
  3194   3261   ** These functions are [deprecated].  In order to maintain
  3195   3262   ** backwards compatibility with older code, these functions continue 
  3196   3263   ** to be supported.  However, new applications should avoid
  3197   3264   ** the use of these functions.  To help encourage people to avoid
  3198   3265   ** using these functions, we are not going to tell you what they do.
  3199   3266   */
  3200   3267   #ifndef SQLITE_OMIT_DEPRECATED
  3201         -SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
  3202         -SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
  3203         -SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
  3204         -SQLITE_DEPRECATED int sqlite3_global_recover(void);
  3205         -SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
  3206         -SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
         3268  +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
         3269  +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
         3270  +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
         3271  +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
         3272  +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
         3273  +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
  3207   3274   #endif
  3208   3275   
  3209   3276   /*
  3210         -** CAPI3REF: Obtaining SQL Function Parameter Values {H15100} <S20200>
         3277  +** CAPI3REF: Obtaining SQL Function Parameter Values
  3211   3278   **
  3212   3279   ** The C-language implementation of SQL functions and aggregates uses
  3213   3280   ** this set of interface routines to access the parameter values on
  3214   3281   ** the function or aggregate.
  3215   3282   **
  3216   3283   ** The xFunc (for scalar functions) or xStep (for aggregates) parameters
  3217   3284   ** to [sqlite3_create_function()] and [sqlite3_create_function16()]
................................................................................
  3221   3288   ** each parameter to the SQL function.  These routines are used to
  3222   3289   ** extract values from the [sqlite3_value] objects.
  3223   3290   **
  3224   3291   ** These routines work only with [protected sqlite3_value] objects.
  3225   3292   ** Any attempt to use these routines on an [unprotected sqlite3_value]
  3226   3293   ** object results in undefined behavior.
  3227   3294   **
  3228         -** These routines work just like the corresponding [column access functions]
         3295  +** ^These routines work just like the corresponding [column access functions]
  3229   3296   ** except that  these routines take a single [protected sqlite3_value] object
  3230   3297   ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
  3231   3298   **
  3232         -** The sqlite3_value_text16() interface extracts a UTF-16 string
  3233         -** in the native byte-order of the host machine.  The
         3299  +** ^The sqlite3_value_text16() interface extracts a UTF-16 string
         3300  +** in the native byte-order of the host machine.  ^The
  3234   3301   ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
  3235   3302   ** extract UTF-16 strings as big-endian and little-endian respectively.
  3236   3303   **
  3237         -** The sqlite3_value_numeric_type() interface attempts to apply
         3304  +** ^(The sqlite3_value_numeric_type() interface attempts to apply
  3238   3305   ** numeric affinity to the value.  This means that an attempt is
  3239   3306   ** made to convert the value to an integer or floating point.  If
  3240   3307   ** such a conversion is possible without loss of information (in other
  3241   3308   ** words, if the value is a string that looks like a number)
  3242   3309   ** then the conversion is performed.  Otherwise no conversion occurs.
  3243         -** The [SQLITE_INTEGER | datatype] after conversion is returned.
         3310  +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^
  3244   3311   **
  3245   3312   ** Please pay particular attention to the fact that the pointer returned
  3246   3313   ** from [sqlite3_value_blob()], [sqlite3_value_text()], or
  3247   3314   ** [sqlite3_value_text16()] can be invalidated by a subsequent call to
  3248   3315   ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
  3249   3316   ** or [sqlite3_value_text16()].
  3250   3317   **
  3251   3318   ** These routines must be called from the same thread as
  3252   3319   ** the SQL function that supplied the [sqlite3_value*] parameters.
  3253         -**
  3254         -** Requirements:
  3255         -** [H15103] [H15106] [H15109] [H15112] [H15115] [H15118] [H15121] [H15124]
  3256         -** [H15127] [H15130] [H15133] [H15136]
  3257         -*/
  3258         -const void *sqlite3_value_blob(sqlite3_value*);
  3259         -int sqlite3_value_bytes(sqlite3_value*);
  3260         -int sqlite3_value_bytes16(sqlite3_value*);
  3261         -double sqlite3_value_double(sqlite3_value*);
  3262         -int sqlite3_value_int(sqlite3_value*);
  3263         -sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
  3264         -const unsigned char *sqlite3_value_text(sqlite3_value*);
  3265         -const void *sqlite3_value_text16(sqlite3_value*);
  3266         -const void *sqlite3_value_text16le(sqlite3_value*);
  3267         -const void *sqlite3_value_text16be(sqlite3_value*);
  3268         -int sqlite3_value_type(sqlite3_value*);
  3269         -int sqlite3_value_numeric_type(sqlite3_value*);
  3270         -
  3271         -/*
  3272         -** CAPI3REF: Obtain Aggregate Function Context {H16210} <S20200>
  3273         -**
  3274         -** The implementation of aggregate SQL functions use this routine to allocate
  3275         -** a structure for storing their state.
  3276         -**
  3277         -** The first time the sqlite3_aggregate_context() routine is called for a
  3278         -** particular aggregate, SQLite allocates nBytes of memory, zeroes out that
  3279         -** memory, and returns a pointer to it. On second and subsequent calls to
  3280         -** sqlite3_aggregate_context() for the same aggregate function index,
  3281         -** the same buffer is returned. The implementation of the aggregate can use
  3282         -** the returned buffer to accumulate data.
  3283         -**
  3284         -** SQLite automatically frees the allocated buffer when the aggregate
  3285         -** query concludes.
  3286         -**
  3287         -** The first parameter should be a copy of the
         3320  +*/
         3321  +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
         3322  +SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
         3323  +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
         3324  +SQLITE_API double sqlite3_value_double(sqlite3_value*);
         3325  +SQLITE_API int sqlite3_value_int(sqlite3_value*);
         3326  +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
         3327  +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
         3328  +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
         3329  +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
         3330  +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
         3331  +SQLITE_API int sqlite3_value_type(sqlite3_value*);
         3332  +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
         3333  +
         3334  +/*
         3335  +** CAPI3REF: Obtain Aggregate Function Context
         3336  +**
         3337  +** Implementions of aggregate SQL functions use this
         3338  +** routine to allocate memory for storing their state.
         3339  +**
         3340  +** ^The first time the sqlite3_aggregate_context(C,N) routine is called 
         3341  +** for a particular aggregate function, SQLite
         3342  +** allocates N of memory, zeroes out that memory, and returns a pointer
         3343  +** to the new memory. ^On second and subsequent calls to
         3344  +** sqlite3_aggregate_context() for the same aggregate function instance,
         3345  +** the same buffer is returned.  Sqlite3_aggregate_context() is normally
         3346  +** called once for each invocation of the xStep callback and then one
         3347  +** last time when the xFinal callback is invoked.  ^(When no rows match
         3348  +** an aggregate query, the xStep() callback of the aggregate function
         3349  +** implementation is never called and xFinal() is called exactly once.
         3350  +** In those cases, sqlite3_aggregate_context() might be called for the
         3351  +** first time from within xFinal().)^
         3352  +**
         3353  +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer if N is
         3354  +** less than or equal to zero or if a memory allocate error occurs.
         3355  +**
         3356  +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
         3357  +** determined by the N parameter on first successful call.  Changing the
         3358  +** value of N in subsequent call to sqlite3_aggregate_context() within
         3359  +** the same aggregate function instance will not resize the memory
         3360  +** allocation.)^
         3361  +**
         3362  +** ^SQLite automatically frees the memory allocated by 
         3363  +** sqlite3_aggregate_context() when the aggregate query concludes.
         3364  +**
         3365  +** The first parameter must be a copy of the
  3288   3366   ** [sqlite3_context | SQL function context] that is the first parameter
  3289         -** to the callback routine that implements the aggregate function.
         3367  +** to the xStep or xFinal callback routine that implements the aggregate
         3368  +** function.
  3290   3369   **
  3291   3370   ** This routine must be called from the same thread in which
  3292   3371   ** the aggregate SQL function is running.
  3293         -**
  3294         -** Requirements:
  3295         -** [H16211] [H16213] [H16215] [H16217]
  3296   3372   */
  3297         -void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
         3373  +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
  3298   3374   
  3299   3375   /*
  3300         -** CAPI3REF: User Data For Functions {H16240} <S20200>
         3376  +** CAPI3REF: User Data For Functions
  3301   3377   **
  3302         -** The sqlite3_user_data() interface returns a copy of
         3378  +** ^The sqlite3_user_data() interface returns a copy of
  3303   3379   ** the pointer that was the pUserData parameter (the 5th parameter)
  3304   3380   ** of the [sqlite3_create_function()]
  3305   3381   ** and [sqlite3_create_function16()] routines that originally
  3306         -** registered the application defined function. {END}
         3382  +** registered the application defined function.
  3307   3383   **
  3308   3384   ** This routine must be called from the same thread in which
  3309   3385   ** the application-defined function is running.
  3310         -**
  3311         -** Requirements:
  3312         -** [H16243]
  3313   3386   */
  3314         -void *sqlite3_user_data(sqlite3_context*);
         3387  +SQLITE_API void *sqlite3_user_data(sqlite3_context*);
  3315   3388   
  3316   3389   /*
  3317         -** CAPI3REF: Database Connection For Functions {H16250} <S60600><S20200>
         3390  +** CAPI3REF: Database Connection For Functions
  3318   3391   **
  3319         -** The sqlite3_context_db_handle() interface returns a copy of
         3392  +** ^The sqlite3_context_db_handle() interface returns a copy of
  3320   3393   ** the pointer to the [database connection] (the 1st parameter)
  3321   3394   ** of the [sqlite3_create_function()]
  3322   3395   ** and [sqlite3_create_function16()] routines that originally
  3323   3396   ** registered the application defined function.
  3324         -**
  3325         -** Requirements:
  3326         -** [H16253]
  3327   3397   */
  3328         -sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
         3398  +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
  3329   3399   
  3330   3400   /*
  3331         -** CAPI3REF: Function Auxiliary Data {H16270} <S20200>
         3401  +** CAPI3REF: Function Auxiliary Data
  3332   3402   **
  3333   3403   ** The following two functions may be used by scalar SQL functions to
  3334   3404   ** associate metadata with argument values. If the same value is passed to
  3335   3405   ** multiple invocations of the same SQL function during query execution, under
  3336   3406   ** some circumstances the associated metadata may be preserved. This may
  3337   3407   ** be used, for example, to add a regular-expression matching scalar
  3338   3408   ** function. The compiled version of the regular expression is stored as
  3339   3409   ** metadata associated with the SQL value passed as the regular expression
  3340   3410   ** pattern.  The compiled regular expression can be reused on multiple
  3341   3411   ** invocations of the same function so that the original pattern string
  3342   3412   ** does not need to be recompiled on each invocation.
  3343   3413   **
  3344         -** The sqlite3_get_auxdata() interface returns a pointer to the metadata
         3414  +** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata
  3345   3415   ** associated by the sqlite3_set_auxdata() function with the Nth argument
  3346         -** value to the application-defined function. If no metadata has been ever
         3416  +** value to the application-defined function. ^If no metadata has been ever
  3347   3417   ** been set for the Nth argument of the function, or if the corresponding
  3348   3418   ** function parameter has changed since the meta-data was set,
  3349   3419   ** then sqlite3_get_auxdata() returns a NULL pointer.
  3350   3420   **
  3351         -** The sqlite3_set_auxdata() interface saves the metadata
         3421  +** ^The sqlite3_set_auxdata() interface saves the metadata
  3352   3422   ** pointed to by its 3rd parameter as the metadata for the N-th
  3353   3423   ** argument of the application-defined function.  Subsequent
  3354   3424   ** calls to sqlite3_get_auxdata() might return this data, if it has
  3355   3425   ** not been destroyed.
  3356         -** If it is not NULL, SQLite will invoke the destructor
         3426  +** ^If it is not NULL, SQLite will invoke the destructor
  3357   3427   ** function given by the 4th parameter to sqlite3_set_auxdata() on
  3358   3428   ** the metadata when the corresponding function parameter changes
  3359   3429   ** or when the SQL statement completes, whichever comes first.
  3360   3430   **
  3361   3431   ** SQLite is free to call the destructor and drop metadata on any
  3362         -** parameter of any function at any time.  The only guarantee is that
         3432  +** parameter of any function at any time.  ^The only guarantee is that
  3363   3433   ** the destructor will be called before the metadata is dropped.
  3364   3434   **
  3365         -** In practice, metadata is preserved between function calls for
         3435  +** ^(In practice, metadata is preserved between function calls for
  3366   3436   ** expressions that are constant at compile time. This includes literal
  3367         -** values and SQL variables.
         3437  +** values and [parameters].)^
  3368   3438   **
  3369   3439   ** These routines must be called from the same thread in which
  3370   3440   ** the SQL function is running.
  3371         -**
  3372         -** Requirements:
  3373         -** [H16272] [H16274] [H16276] [H16277] [H16278] [H16279]
  3374   3441   */
  3375         -void *sqlite3_get_auxdata(sqlite3_context*, int N);
  3376         -void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
         3442  +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
         3443  +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
  3377   3444   
  3378   3445   
  3379   3446   /*
  3380         -** CAPI3REF: Constants Defining Special Destructor Behavior {H10280} <S30100>
         3447  +** CAPI3REF: Constants Defining Special Destructor Behavior
  3381   3448   **
  3382   3449   ** These are special values for the destructor that is passed in as the
  3383         -** final argument to routines like [sqlite3_result_blob()].  If the destructor
         3450  +** final argument to routines like [sqlite3_result_blob()].  ^If the destructor
  3384   3451   ** argument is SQLITE_STATIC, it means that the content pointer is constant
  3385         -** and will never change.  It does not need to be destroyed.  The
         3452  +** and will never change.  It does not need to be destroyed.  ^The
  3386   3453   ** SQLITE_TRANSIENT value means that the content will likely change in
  3387   3454   ** the near future and that SQLite should make its own private copy of
  3388   3455   ** the content before returning.
  3389   3456   **
  3390   3457   ** The typedef is necessary to work around problems in certain
  3391   3458   ** C++ compilers.  See ticket #2191.
  3392   3459   */
  3393   3460   typedef void (*sqlite3_destructor_type)(void*);
  3394   3461   #define SQLITE_STATIC      ((sqlite3_destructor_type)0)
  3395   3462   #define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
  3396   3463   
  3397   3464   /*
  3398         -** CAPI3REF: Setting The Result Of An SQL Function {H16400} <S20200>
         3465  +** CAPI3REF: Setting The Result Of An SQL Function
  3399   3466   **
  3400   3467   ** These routines are used by the xFunc or xFinal callbacks that
  3401   3468   ** implement SQL functions and aggregates.  See
  3402   3469   ** [sqlite3_create_function()] and [sqlite3_create_function16()]
  3403   3470   ** for additional information.
  3404   3471   **
  3405   3472   ** These functions work very much like the [parameter binding] family of
  3406   3473   ** functions used to bind values to host parameters in prepared statements.
  3407   3474   ** Refer to the [SQL parameter] documentation for additional information.
  3408   3475   **
  3409         -** The sqlite3_result_blob() interface sets the result from
         3476  +** ^The sqlite3_result_blob() interface sets the result from
  3410   3477   ** an application-defined function to be the BLOB whose content is pointed
  3411   3478   ** to by the second parameter and which is N bytes long where N is the
  3412   3479   ** third parameter.
  3413   3480   **
  3414         -** The sqlite3_result_zeroblob() interfaces set the result of
         3481  +** ^The sqlite3_result_zeroblob() interfaces set the result of
  3415   3482   ** the application-defined function to be a BLOB containing all zero
  3416   3483   ** bytes and N bytes in size, where N is the value of the 2nd parameter.
  3417   3484   **
  3418         -** The sqlite3_result_double() interface sets the result from
         3485  +** ^The sqlite3_result_double() interface sets the result from
  3419   3486   ** an application-defined function to be a floating point value specified
  3420   3487   ** by its 2nd argument.
  3421   3488   **
  3422         -** The sqlite3_result_error() and sqlite3_result_error16() functions
         3489  +** ^The sqlite3_result_error() and sqlite3_result_error16() functions
  3423   3490   ** cause the implemented SQL function to throw an exception.
  3424         -** SQLite uses the string pointed to by the
         3491  +** ^SQLite uses the string pointed to by the
  3425   3492   ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
  3426         -** as the text of an error message.  SQLite interprets the error
  3427         -** message string from sqlite3_result_error() as UTF-8. SQLite
         3493  +** as the text of an error message.  ^SQLite interprets the error
         3494  +** message string from sqlite3_result_error() as UTF-8. ^SQLite
  3428   3495   ** interprets the string from sqlite3_result_error16() as UTF-16 in native
  3429         -** byte order.  If the third parameter to sqlite3_result_error()
         3496  +** byte order.  ^If the third parameter to sqlite3_result_error()
  3430   3497   ** or sqlite3_result_error16() is negative then SQLite takes as the error
  3431   3498   ** message all text up through the first zero character.
  3432         -** If the third parameter to sqlite3_result_error() or
         3499  +** ^If the third parameter to sqlite3_result_error() or
  3433   3500   ** sqlite3_result_error16() is non-negative then SQLite takes that many
  3434   3501   ** bytes (not characters) from the 2nd parameter as the error message.
  3435         -** The sqlite3_result_error() and sqlite3_result_error16()
         3502  +** ^The sqlite3_result_error() and sqlite3_result_error16()
  3436   3503   ** routines make a private copy of the error message text before
  3437   3504   ** they return.  Hence, the calling function can deallocate or
  3438   3505   ** modify the text after they return without harm.
  3439         -** The sqlite3_result_error_code() function changes the error code
  3440         -** returned by SQLite as a result of an error in a function.  By default,
  3441         -** the error code is SQLITE_ERROR.  A subsequent call to sqlite3_result_error()
         3506  +** ^The sqlite3_result_error_code() function changes the error code
         3507  +** returned by SQLite as a result of an error in a function.  ^By default,
         3508  +** the error code is SQLITE_ERROR.  ^A subsequent call to sqlite3_result_error()
  3442   3509   ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
  3443   3510   **
  3444         -** The sqlite3_result_toobig() interface causes SQLite to throw an error
  3445         -** indicating that a string or BLOB is to long to represent.
         3511  +** ^The sqlite3_result_toobig() interface causes SQLite to throw an error
         3512  +** indicating that a string or BLOB is too long to represent.
  3446   3513   **
  3447         -** The sqlite3_result_nomem() interface causes SQLite to throw an error
         3514  +** ^The sqlite3_result_nomem() interface causes SQLite to throw an error
  3448   3515   ** indicating that a memory allocation failed.
  3449   3516   **
  3450         -** The sqlite3_result_int() interface sets the return value
         3517  +** ^The sqlite3_result_int() interface sets the return value
  3451   3518   ** of the application-defined function to be the 32-bit signed integer
  3452   3519   ** value given in the 2nd argument.
  3453         -** The sqlite3_result_int64() interface sets the return value
         3520  +** ^The sqlite3_result_int64() interface sets the return value
  3454   3521   ** of the application-defined function to be the 64-bit signed integer
  3455   3522   ** value given in the 2nd argument.
  3456   3523   **
  3457         -** The sqlite3_result_null() interface sets the return value
         3524  +** ^The sqlite3_result_null() interface sets the return value
  3458   3525   ** of the application-defined function to be NULL.
  3459   3526   **
  3460         -** The sqlite3_result_text(), sqlite3_result_text16(),
         3527  +** ^The sqlite3_result_text(), sqlite3_result_text16(),
  3461   3528   ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
  3462   3529   ** set the return value of the application-defined function to be
  3463   3530   ** a text string which is represented as UTF-8, UTF-16 native byte order,
  3464   3531   ** UTF-16 little endian, or UTF-16 big endian, respectively.
  3465         -** SQLite takes the text result from the application from
         3532  +** ^SQLite takes the text result from the application from
  3466   3533   ** the 2nd parameter of the sqlite3_result_text* interfaces.
  3467         -** If the 3rd parameter to the sqlite3_result_text* interfaces
         3534  +** ^If the 3rd parameter to the sqlite3_result_text* interfaces
  3468   3535   ** is negative, then SQLite takes result text from the 2nd parameter
  3469   3536   ** through the first zero character.
  3470         -** If the 3rd parameter to the sqlite3_result_text* interfaces
         3537  +** ^If the 3rd parameter to the sqlite3_result_text* interfaces
  3471   3538   ** is non-negative, then as many bytes (not characters) of the text
  3472   3539   ** pointed to by the 2nd parameter are taken as the application-defined
  3473   3540   ** function result.
  3474         -** If the 4th parameter to the sqlite3_result_text* interfaces
         3541  +** ^If the 4th parameter to the sqlite3_result_text* interfaces
  3475   3542   ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
  3476   3543   ** function as the destructor on the text or BLOB result when it has
  3477   3544   ** finished using that result.
  3478         -** If the 4th parameter to the sqlite3_result_text* interfaces or
         3545  +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to
  3479   3546   ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
  3480   3547   ** assumes that the text or BLOB result is in constant space and does not
  3481         -** copy the it or call a destructor when it has finished using that result.
  3482         -** If the 4th parameter to the sqlite3_result_text* interfaces
         3548  +** copy the content of the parameter nor call a destructor on the content
         3549  +** when it has finished using that result.
         3550  +** ^If the 4th parameter to the sqlite3_result_text* interfaces
  3483   3551   ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
  3484   3552   ** then SQLite makes a copy of the result into space obtained from
  3485   3553   ** from [sqlite3_malloc()] before it returns.
  3486   3554   **
  3487         -** The sqlite3_result_value() interface sets the result of
         3555  +** ^The sqlite3_result_value() interface sets the result of
  3488   3556   ** the application-defined function to be a copy the
  3489         -** [unprotected sqlite3_value] object specified by the 2nd parameter.  The
         3557  +** [unprotected sqlite3_value] object specified by the 2nd parameter.  ^The
  3490   3558   ** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
  3491   3559   ** so that the [sqlite3_value] specified in the parameter may change or
  3492   3560   ** be deallocated after sqlite3_result_value() returns without harm.
  3493         -** A [protected sqlite3_value] object may always be used where an
         3561  +** ^A [protected sqlite3_value] object may always be used where an
  3494   3562   ** [unprotected sqlite3_value] object is required, so either
  3495   3563   ** kind of [sqlite3_value] object can be used with this interface.
  3496   3564   **
  3497   3565   ** If these routines are called from within the different thread
  3498   3566   ** than the one containing the application-defined function that received
  3499   3567   ** the [sqlite3_context] pointer, the results are undefined.
  3500         -**
  3501         -** Requirements:
  3502         -** [H16403] [H16406] [H16409] [H16412] [H16415] [H16418] [H16421] [H16424]
  3503         -** [H16427] [H16430] [H16433] [H16436] [H16439] [H16442] [H16445] [H16448]
  3504         -** [H16451] [H16454] [H16457] [H16460] [H16463]
  3505         -*/
  3506         -void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
  3507         -void sqlite3_result_double(sqlite3_context*, double);
  3508         -void sqlite3_result_error(sqlite3_context*, const char*, int);
  3509         -void sqlite3_result_error16(sqlite3_context*, const void*, int);
  3510         -void sqlite3_result_error_toobig(sqlite3_context*);
  3511         -void sqlite3_result_error_nomem(sqlite3_context*);
  3512         -void sqlite3_result_error_code(sqlite3_context*, int);
  3513         -void sqlite3_result_int(sqlite3_context*, int);
  3514         -void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
  3515         -void sqlite3_result_null(sqlite3_context*);
  3516         -void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
  3517         -void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
  3518         -void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
  3519         -void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
  3520         -void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
  3521         -void sqlite3_result_zeroblob(sqlite3_context*, int n);
  3522         -
  3523         -/*
  3524         -** CAPI3REF: Define New Collating Sequences {H16600} <S20300>
         3568  +*/
         3569  +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
         3570  +SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
         3571  +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
         3572  +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
         3573  +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
         3574  +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
         3575  +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
         3576  +SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
         3577  +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
         3578  +SQLITE_API void sqlite3_result_null(sqlite3_context*);
         3579  +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
         3580  +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
         3581  +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
         3582  +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
         3583  +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
         3584  +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
         3585  +
         3586  +/*
         3587  +** CAPI3REF: Define New Collating Sequences
  3525   3588   **
  3526   3589   ** These functions are used to add new collation sequences to the
  3527   3590   ** [database connection] specified as the first argument.
  3528   3591   **
  3529         -** The name of the new collation sequence is specified as a UTF-8 string
         3592  +** ^The name of the new collation sequence is specified as a UTF-8 string
  3530   3593   ** for sqlite3_create_collation() and sqlite3_create_collation_v2()
  3531         -** and a UTF-16 string for sqlite3_create_collation16(). In all cases
         3594  +** and a UTF-16 string for sqlite3_create_collation16(). ^In all cases
  3532   3595   ** the name is passed as the second function argument.
  3533   3596   **
  3534         -** The third argument may be one of the constants [SQLITE_UTF8],
         3597  +** ^The third argument may be one of the constants [SQLITE_UTF8],
  3535   3598   ** [SQLITE_UTF16LE], or [SQLITE_UTF16BE], indicating that the user-supplied
  3536   3599   ** routine expects to be passed pointers to strings encoded using UTF-8,
  3537         -** UTF-16 little-endian, or UTF-16 big-endian, respectively. The
         3600  +** UTF-16 little-endian, or UTF-16 big-endian, respectively. ^The
  3538   3601   ** third argument might also be [SQLITE_UTF16] to indicate that the routine
  3539   3602   ** expects pointers to be UTF-16 strings in the native byte order, or the
  3540   3603   ** argument can be [SQLITE_UTF16_ALIGNED] if the
  3541   3604   ** the routine expects pointers to 16-bit word aligned strings
  3542   3605   ** of UTF-16 in the native byte order.
  3543   3606   **
  3544   3607   ** A pointer to the user supplied routine must be passed as the fifth
  3545         -** argument.  If it is NULL, this is the same as deleting the collation
         3608  +** argument.  ^If it is NULL, this is the same as deleting the collation
  3546   3609   ** sequence (so that SQLite cannot call it anymore).
  3547         -** Each time the application supplied function is invoked, it is passed
         3610  +** ^Each time the application supplied function is invoked, it is passed
  3548   3611   ** as its first parameter a copy of the void* passed as the fourth argument
  3549   3612   ** to sqlite3_create_collation() or sqlite3_create_collation16().
  3550   3613   **
  3551         -** The remaining arguments to the application-supplied routine are two strings,
         3614  +** ^The remaining arguments to the application-supplied routine are two strings,
  3552   3615   ** each represented by a (length, data) pair and encoded in the encoding
  3553   3616   ** that was passed as the third argument when the collation sequence was
  3554         -** registered. {END}  The application defined collation routine should
         3617  +** registered.  The application defined collation routine should
  3555   3618   ** return negative, zero or positive if the first string is less than,
  3556   3619   ** equal to, or greater than the second string. i.e. (STRING1 - STRING2).
  3557   3620   **
  3558         -** The sqlite3_create_collation_v2() works like sqlite3_create_collation()
         3621  +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation()
  3559   3622   ** except that it takes an extra argument which is a destructor for
  3560         -** the collation.  The destructor is called when the collation is
         3623  +** the collation.  ^The destructor is called when the collation is
  3561   3624   ** destroyed and is passed a copy of the fourth parameter void* pointer
  3562   3625   ** of the sqlite3_create_collation_v2().
  3563         -** Collations are destroyed when they are overridden by later calls to the
         3626  +** ^Collations are destroyed when they are overridden by later calls to the
  3564   3627   ** collation creation functions or when the [database connection] is closed
  3565   3628   ** using [sqlite3_close()].
  3566   3629   **
  3567   3630   ** See also:  [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
  3568         -**
  3569         -** Requirements:
  3570         -** [H16603] [H16604] [H16606] [H16609] [H16612] [H16615] [H16618] [H16621]
  3571         -** [H16624] [H16627] [H16630]
  3572   3631   */
  3573         -int sqlite3_create_collation(
         3632  +SQLITE_API int sqlite3_create_collation(
  3574   3633     sqlite3*, 
  3575   3634     const char *zName, 
  3576   3635     int eTextRep, 
  3577   3636     void*,
  3578   3637     int(*xCompare)(void*,int,const void*,int,const void*)
  3579   3638   );
  3580         -int sqlite3_create_collation_v2(
         3639  +SQLITE_API int sqlite3_create_collation_v2(
  3581   3640     sqlite3*, 
  3582   3641     const char *zName, 
  3583   3642     int eTextRep, 
  3584   3643     void*,
  3585   3644     int(*xCompare)(void*,int,const void*,int,const void*),
  3586   3645     void(*xDestroy)(void*)
  3587   3646   );
  3588         -int sqlite3_create_collation16(
         3647  +SQLITE_API int sqlite3_create_collation16(
  3589   3648     sqlite3*, 
  3590   3649     const void *zName,
  3591   3650     int eTextRep, 
  3592   3651     void*,
  3593   3652     int(*xCompare)(void*,int,const void*,int,const void*)
  3594   3653   );
  3595   3654   
  3596   3655   /*
  3597         -** CAPI3REF: Collation Needed Callbacks {H16700} <S20300>
         3656  +** CAPI3REF: Collation Needed Callbacks
  3598   3657   **
  3599         -** To avoid having to register all collation sequences before a database
         3658  +** ^To avoid having to register all collation sequences before a database
  3600   3659   ** can be used, a single callback function may be registered with the
  3601         -** [database connection] to be called whenever an undefined collation
         3660  +** [database connection] to be invoked whenever an undefined collation
  3602   3661   ** sequence is required.
  3603   3662   **
  3604         -** If the function is registered using the sqlite3_collation_needed() API,
         3663  +** ^If the function is registered using the sqlite3_collation_needed() API,
  3605   3664   ** then it is passed the names of undefined collation sequences as strings
  3606         -** encoded in UTF-8. {H16703} If sqlite3_collation_needed16() is used,
         3665  +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
  3607   3666   ** the names are passed as UTF-16 in machine native byte order.
  3608         -** A call to either function replaces any existing callback.
         3667  +** ^A call to either function replaces the existing collation-needed callback.
  3609   3668   **
  3610         -** When the callback is invoked, the first argument passed is a copy
         3669  +** ^(When the callback is invoked, the first argument passed is a copy
  3611   3670   ** of the second argument to sqlite3_collation_needed() or
  3612   3671   ** sqlite3_collation_needed16().  The second argument is the database
  3613   3672   ** connection.  The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE],
  3614   3673   ** or [SQLITE_UTF16LE], indicating the most desirable form of the collation
  3615   3674   ** sequence function required.  The fourth parameter is the name of the
  3616         -** required collation sequence.
         3675  +** required collation sequence.)^
  3617   3676   **
  3618   3677   ** The callback function should register the desired collation using
  3619   3678   ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
  3620   3679   ** [sqlite3_create_collation_v2()].
  3621         -**
  3622         -** Requirements:
  3623         -** [H16702] [H16704] [H16706]
  3624   3680   */
  3625         -int sqlite3_collation_needed(
         3681  +SQLITE_API int sqlite3_collation_needed(
  3626   3682     sqlite3*, 
  3627   3683     void*, 
  3628   3684     void(*)(void*,sqlite3*,int eTextRep,const char*)
  3629   3685   );
  3630         -int sqlite3_collation_needed16(
         3686  +SQLITE_API int sqlite3_collation_needed16(
  3631   3687     sqlite3*, 
  3632   3688     void*,
  3633   3689     void(*)(void*,sqlite3*,int eTextRep,const void*)
  3634   3690   );
  3635   3691   
         3692  +#if SQLITE_HAS_CODEC
  3636   3693   /*
  3637   3694   ** Specify the key for an encrypted database.  This routine should be
  3638   3695   ** called right after sqlite3_open().
  3639   3696   **
  3640   3697   ** The code to implement this API is not available in the public release
  3641   3698   ** of SQLite.
  3642   3699   */
  3643         -int sqlite3_key(
         3700  +SQLITE_API int sqlite3_key(
  3644   3701     sqlite3 *db,                   /* Database to be rekeyed */
  3645   3702     const void *pKey, int nKey     /* The key */
  3646   3703   );
  3647   3704   
  3648   3705   /*
  3649   3706   ** Change the key on an open database.  If the current database is not
  3650   3707   ** encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
  3651   3708   ** database is decrypted.
  3652   3709   **
  3653   3710   ** The code to implement this API is not available in the public release
  3654   3711   ** of SQLite.
  3655   3712   */
  3656         -int sqlite3_rekey(
         3713  +SQLITE_API int sqlite3_rekey(
  3657   3714     sqlite3 *db,                   /* Database to be rekeyed */
  3658   3715     const void *pKey, int nKey     /* The new key */
  3659   3716   );
  3660   3717   
  3661   3718   /*
  3662         -** CAPI3REF: Suspend Execution For A Short Time {H10530} <S40410>
         3719  +** Specify the activation key for a SEE database.  Unless 
         3720  +** activated, none of the SEE routines will work.
         3721  +*/
         3722  +SQLITE_API void sqlite3_activate_see(
         3723  +  const char *zPassPhrase        /* Activation phrase */
         3724  +);
         3725  +#endif
         3726  +
         3727  +#ifdef SQLITE_ENABLE_CEROD
         3728  +/*
         3729  +** Specify the activation key for a CEROD database.  Unless 
         3730  +** activated, none of the CEROD routines will work.
         3731  +*/
         3732  +SQLITE_API void sqlite3_activate_cerod(
         3733  +  const char *zPassPhrase        /* Activation phrase */
         3734  +);
         3735  +#endif
         3736  +
         3737  +/*
         3738  +** CAPI3REF: Suspend Execution For A Short Time
  3663   3739   **
  3664         -** The sqlite3_sleep() function causes the current thread to suspend execution
         3740  +** ^The sqlite3_sleep() function causes the current thread to suspend execution
  3665   3741   ** for at least a number of milliseconds specified in its parameter.
  3666   3742   **
  3667         -** If the operating system does not support sleep requests with
         3743  +** ^If the operating system does not support sleep requests with
  3668   3744   ** millisecond time resolution, then the time will be rounded up to
  3669         -** the nearest second. The number of milliseconds of sleep actually
         3745  +** the nearest second. ^The number of milliseconds of sleep actually
  3670   3746   ** requested from the operating system is returned.
  3671   3747   **
  3672         -** SQLite implements this interface by calling the xSleep()
         3748  +** ^SQLite implements this interface by calling the xSleep()
  3673   3749   ** method of the default [sqlite3_vfs] object.
  3674         -**
  3675         -** Requirements: [H10533] [H10536]
  3676   3750   */
  3677         -int sqlite3_sleep(int);
         3751  +SQLITE_API int sqlite3_sleep(int);
  3678   3752   
  3679   3753   /*
  3680         -** CAPI3REF: Name Of The Folder Holding Temporary Files {H10310} <S20000>
         3754  +** CAPI3REF: Name Of The Folder Holding Temporary Files
  3681   3755   **
  3682         -** If this global variable is made to point to a string which is
         3756  +** ^(If this global variable is made to point to a string which is
  3683   3757   ** the name of a folder (a.k.a. directory), then all temporary files
  3684         -** created by SQLite will be placed in that directory.  If this variable
         3758  +** created by SQLite when using a built-in [sqlite3_vfs | VFS]
         3759  +** will be placed in that directory.)^  ^If this variable
  3685   3760   ** is a NULL pointer, then SQLite performs a search for an appropriate
  3686   3761   ** temporary file directory.
  3687   3762   **
  3688   3763   ** It is not safe to read or modify this variable in more than one
  3689   3764   ** thread at a time.  It is not safe to read or modify this variable
  3690   3765   ** if a [database connection] is being used at the same time in a separate
  3691   3766   ** thread.
  3692   3767   ** It is intended that this variable be set once
  3693   3768   ** as part of process initialization and before any SQLite interface
  3694   3769   ** routines have been called and that this variable remain unchanged
  3695   3770   ** thereafter.
  3696   3771   **
  3697         -** The [temp_store_directory pragma] may modify this variable and cause
  3698         -** it to point to memory obtained from [sqlite3_malloc].  Furthermore,
         3772  +** ^The [temp_store_directory pragma] may modify this variable and cause
         3773  +** it to point to memory obtained from [sqlite3_malloc].  ^Furthermore,
  3699   3774   ** the [temp_store_directory pragma] always assumes that any string
  3700   3775   ** that this variable points to is held in memory obtained from 
  3701   3776   ** [sqlite3_malloc] and the pragma may attempt to free that memory
  3702   3777   ** using [sqlite3_free].
  3703   3778   ** Hence, if this variable is modified directly, either it should be
  3704   3779   ** made NULL or made to point to memory obtained from [sqlite3_malloc]
  3705   3780   ** or else the use of the [temp_store_directory pragma] should be avoided.
  3706   3781   */
  3707         -SQLITE_EXTERN char *sqlite3_temp_directory;
         3782  +SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory;
  3708   3783   
  3709   3784   /*
  3710         -** CAPI3REF: Test For Auto-Commit Mode {H12930} <S60200>
         3785  +** CAPI3REF: Test For Auto-Commit Mode
  3711   3786   ** KEYWORDS: {autocommit mode}
  3712   3787   **
  3713         -** The sqlite3_get_autocommit() interface returns non-zero or
         3788  +** ^The sqlite3_get_autocommit() interface returns non-zero or
  3714   3789   ** zero if the given database connection is or is not in autocommit mode,
  3715         -** respectively.  Autocommit mode is on by default.
  3716         -** Autocommit mode is disabled by a [BEGIN] statement.
  3717         -** Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
         3790  +** respectively.  ^Autocommit mode is on by default.
         3791  +** ^Autocommit mode is disabled by a [BEGIN] statement.
         3792  +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
  3718   3793   **
  3719   3794   ** If certain kinds of errors occur on a statement within a multi-statement
  3720   3795   ** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
  3721   3796   ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
  3722   3797   ** transaction might be rolled back automatically.  The only way to
  3723   3798   ** find out whether SQLite automatically rolled back the transaction after
  3724   3799   ** an error is to use this function.
  3725   3800   **
  3726   3801   ** If another thread changes the autocommit status of the database
  3727   3802   ** connection while this routine is running, then the return value
  3728   3803   ** is undefined.
  3729         -**
  3730         -** Requirements: [H12931] [H12932] [H12933] [H12934]
  3731   3804   */
  3732         -int sqlite3_get_autocommit(sqlite3*);
         3805  +SQLITE_API int sqlite3_get_autocommit(sqlite3*);
  3733   3806   
  3734   3807   /*
  3735         -** CAPI3REF: Find The Database Handle Of A Prepared Statement {H13120} <S60600>
         3808  +** CAPI3REF: Find The Database Handle Of A Prepared Statement
  3736   3809   **
  3737         -** The sqlite3_db_handle interface returns the [database connection] handle
  3738         -** to which a [prepared statement] belongs.  The [database connection]
  3739         -** returned by sqlite3_db_handle is the same [database connection] that was the first argument
         3810  +** ^The sqlite3_db_handle interface returns the [database connection] handle
         3811  +** to which a [prepared statement] belongs.  ^The [database connection]
         3812  +** returned by sqlite3_db_handle is the same [database connection]
         3813  +** that was the first argument
  3740   3814   ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
  3741   3815   ** create the statement in the first place.
  3742         -**
  3743         -** Requirements: [H13123]
  3744   3816   */
  3745         -sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
         3817  +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
  3746   3818   
  3747   3819   /*
  3748         -** CAPI3REF: Find the next prepared statement {H13140} <S60600>
         3820  +** CAPI3REF: Find the next prepared statement
  3749   3821   **
  3750         -** This interface returns a pointer to the next [prepared statement] after
  3751         -** pStmt associated with the [database connection] pDb.  If pStmt is NULL
         3822  +** ^This interface returns a pointer to the next [prepared statement] after
         3823  +** pStmt associated with the [database connection] pDb.  ^If pStmt is NULL
  3752   3824   ** then this interface returns a pointer to the first prepared statement
  3753         -** associated with the database connection pDb.  If no prepared statement
         3825  +** associated with the database connection pDb.  ^If no prepared statement
  3754   3826   ** satisfies the conditions of this routine, it returns NULL.
  3755   3827   **
  3756   3828   ** The [database connection] pointer D in a call to
  3757   3829   ** [sqlite3_next_stmt(D,S)] must refer to an open database
  3758   3830   ** connection and in particular must not be a NULL pointer.
  3759         -**
  3760         -** Requirements: [H13143] [H13146] [H13149] [H13152]
  3761   3831   */
  3762         -sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
         3832  +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
  3763   3833   
  3764   3834   /*
  3765         -** CAPI3REF: Commit And Rollback Notification Callbacks {H12950} <S60400>
         3835  +** CAPI3REF: Commit And Rollback Notification Callbacks
  3766   3836   **
  3767         -** The sqlite3_commit_hook() interface registers a callback
         3837  +** ^The sqlite3_commit_hook() interface registers a callback
  3768   3838   ** function to be invoked whenever a transaction is [COMMIT | committed].
  3769         -** Any callback set by a previous call to sqlite3_commit_hook()
         3839  +** ^Any callback set by a previous call to sqlite3_commit_hook()
  3770   3840   ** for the same database connection is overridden.
  3771         -** The sqlite3_rollback_hook() interface registers a callback
         3841  +** ^The sqlite3_rollback_hook() interface registers a callback
  3772   3842   ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
  3773         -** Any callback set by a previous call to sqlite3_commit_hook()
         3843  +** ^Any callback set by a previous call to sqlite3_rollback_hook()
  3774   3844   ** for the same database connection is overridden.
  3775         -** The pArg argument is passed through to the callback.
  3776         -** If the callback on a commit hook function returns non-zero,
         3845  +** ^The pArg argument is passed through to the callback.
         3846  +** ^If the callback on a commit hook function returns non-zero,
  3777   3847   ** then the commit is converted into a rollback.
  3778   3848   **
  3779         -** If another function was previously registered, its
  3780         -** pArg value is returned.  Otherwise NULL is returned.
         3849  +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
         3850  +** return the P argument from the previous call of the same function
         3851  +** on the same [database connection] D, or NULL for
         3852  +** the first call for each function on D.
  3781   3853   **
  3782   3854   ** The callback implementation must not do anything that will modify
  3783   3855   ** the database connection that invoked the callback.  Any actions
  3784   3856   ** to modify the database connection must be deferred until after the
  3785   3857   ** completion of the [sqlite3_step()] call that triggered the commit
  3786   3858   ** or rollback hook in the first place.
  3787   3859   ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
  3788   3860   ** database connections for the meaning of "modify" in this paragraph.
  3789   3861   **
  3790         -** Registering a NULL function disables the callback.
         3862  +** ^Registering a NULL function disables the callback.
  3791   3863   **
  3792         -** When the commit hook callback routine returns zero, the [COMMIT]
  3793         -** operation is allowed to continue normally.  If the commit hook
         3864  +** ^When the commit hook callback routine returns zero, the [COMMIT]
         3865  +** operation is allowed to continue normally.  ^If the commit hook
  3794   3866   ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
  3795         -** The rollback hook is invoked on a rollback that results from a commit
         3867  +** ^The rollback hook is invoked on a rollback that results from a commit
  3796   3868   ** hook returning non-zero, just as it would be with any other rollback.
  3797   3869   **
  3798         -** For the purposes of this API, a transaction is said to have been
         3870  +** ^For the purposes of this API, a transaction is said to have been
  3799   3871   ** rolled back if an explicit "ROLLBACK" statement is executed, or
  3800   3872   ** an error or constraint causes an implicit rollback to occur.
  3801         -** The rollback callback is not invoked if a transaction is
         3873  +** ^The rollback callback is not invoked if a transaction is
  3802   3874   ** automatically rolled back because the database connection is closed.
  3803         -** The rollback callback is not invoked if a transaction is
         3875  +** ^The rollback callback is not invoked if a transaction is
  3804   3876   ** rolled back because a commit callback returned non-zero.
  3805         -** <todo> Check on this </todo>
  3806   3877   **
  3807   3878   ** See also the [sqlite3_update_hook()] interface.
  3808         -**
  3809         -** Requirements:
  3810         -** [H12951] [H12952] [H12953] [H12954] [H12955]
  3811         -** [H12961] [H12962] [H12963] [H12964]
  3812   3879   */
  3813         -void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
  3814         -void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
         3880  +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
         3881  +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
  3815   3882   
  3816   3883   /*
  3817         -** CAPI3REF: Data Change Notification Callbacks {H12970} <S60400>
         3884  +** CAPI3REF: Data Change Notification Callbacks
  3818   3885   **
  3819         -** The sqlite3_update_hook() interface registers a callback function
         3886  +** ^The sqlite3_update_hook() interface registers a callback function
  3820   3887   ** with the [database connection] identified by the first argument
  3821   3888   ** to be invoked whenever a row is updated, inserted or deleted.
  3822         -** Any callback set by a previous call to this function
         3889  +** ^Any callback set by a previous call to this function
  3823   3890   ** for the same database connection is overridden.
  3824   3891   **
  3825         -** The second argument is a pointer to the function to invoke when a
         3892  +** ^The second argument is a pointer to the function to invoke when a
  3826   3893   ** row is updated, inserted or deleted.
  3827         -** The first argument to the callback is a copy of the third argument
         3894  +** ^The first argument to the callback is a copy of the third argument
  3828   3895   ** to sqlite3_update_hook().
  3829         -** The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
         3896  +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
  3830   3897   ** or [SQLITE_UPDATE], depending on the operation that caused the callback
  3831   3898   ** to be invoked.
  3832         -** The third and fourth arguments to the callback contain pointers to the
         3899  +** ^The third and fourth arguments to the callback contain pointers to the
  3833   3900   ** database and table name containing the affected row.
  3834         -** The final callback parameter is the [rowid] of the row.
  3835         -** In the case of an update, this is the [rowid] after the update takes place.
         3901  +** ^The final callback parameter is the [rowid] of the row.
         3902  +** ^In the case of an update, this is the [rowid] after the update takes place.
  3836   3903   **
  3837         -** The update hook is not invoked when internal system tables are
  3838         -** modified (i.e. sqlite_master and sqlite_sequence).
         3904  +** ^(The update hook is not invoked when internal system tables are
         3905  +** modified (i.e. sqlite_master and sqlite_sequence).)^
  3839   3906   **
  3840         -** In the current implementation, the update hook
         3907  +** ^In the current implementation, the update hook
  3841   3908   ** is not invoked when duplication rows are deleted because of an
  3842         -** [ON CONFLICT | ON CONFLICT REPLACE] clause.  Nor is the update hook
         3909  +** [ON CONFLICT | ON CONFLICT REPLACE] clause.  ^Nor is the update hook
  3843   3910   ** invoked when rows are deleted using the [truncate optimization].
  3844   3911   ** The exceptions defined in this paragraph might change in a future
  3845   3912   ** release of SQLite.
  3846   3913   **
  3847   3914   ** The update hook implementation must not do anything that will modify
  3848   3915   ** the database connection that invoked the update hook.  Any actions
  3849   3916   ** to modify the database connection must be deferred until after the
  3850   3917   ** completion of the [sqlite3_step()] call that triggered the update hook.
  3851   3918   ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
  3852   3919   ** database connections for the meaning of "modify" in this paragraph.
  3853   3920   **
  3854         -** If another function was previously registered, its pArg value
  3855         -** is returned.  Otherwise NULL is returned.
         3921  +** ^The sqlite3_update_hook(D,C,P) function
         3922  +** returns the P argument from the previous call
         3923  +** on the same [database connection] D, or NULL for
         3924  +** the first call on D.
  3856   3925   **
  3857   3926   ** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
  3858   3927   ** interfaces.
  3859         -**
  3860         -** Requirements:
  3861         -** [H12971] [H12973] [H12975] [H12977] [H12979] [H12981] [H12983] [H12986]
  3862   3928   */
  3863         -void *sqlite3_update_hook(
         3929  +SQLITE_API void *sqlite3_update_hook(
  3864   3930     sqlite3*, 
  3865   3931     void(*)(void *,int ,char const *,char const *,sqlite3_int64),
  3866   3932     void*
  3867   3933   );
  3868   3934   
  3869   3935   /*
  3870         -** CAPI3REF: Enable Or Disable Shared Pager Cache {H10330} <S30900>
  3871         -** KEYWORDS: {shared cache} {shared cache mode}
         3936  +** CAPI3REF: Enable Or Disable Shared Pager Cache
         3937  +** KEYWORDS: {shared cache}
  3872   3938   **
  3873         -** This routine enables or disables the sharing of the database cache
         3939  +** ^(This routine enables or disables the sharing of the database cache
  3874   3940   ** and schema data structures between [database connection | connections]
  3875   3941   ** to the same database. Sharing is enabled if the argument is true
  3876         -** and disabled if the argument is false.
         3942  +** and disabled if the argument is false.)^
  3877   3943   **
  3878         -** Cache sharing is enabled and disabled for an entire process.
         3944  +** ^Cache sharing is enabled and disabled for an entire process.
  3879   3945   ** This is a change as of SQLite version 3.5.0. In prior versions of SQLite,
  3880   3946   ** sharing was enabled or disabled for each thread separately.
  3881   3947   **
  3882         -** The cache sharing mode set by this interface effects all subsequent
         3948  +** ^(The cache sharing mode set by this interface effects all subsequent
  3883   3949   ** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
  3884   3950   ** Existing database connections continue use the sharing mode
  3885         -** that was in effect at the time they were opened.
         3951  +** that was in effect at the time they were opened.)^
  3886   3952   **
  3887         -** Virtual tables cannot be used with a shared cache.  When shared
  3888         -** cache is enabled, the [sqlite3_create_module()] API used to register
  3889         -** virtual tables will always return an error.
         3953  +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
         3954  +** successfully.  An [error code] is returned otherwise.)^
  3890   3955   **
  3891         -** This routine returns [SQLITE_OK] if shared cache was enabled or disabled
  3892         -** successfully.  An [error code] is returned otherwise.
  3893         -**
  3894         -** Shared cache is disabled by default. But this might change in
         3956  +** ^Shared cache is disabled by default. But this might change in
  3895   3957   ** future releases of SQLite.  Applications that care about shared
  3896   3958   ** cache setting should set it explicitly.
  3897   3959   **
  3898   3960   ** See Also:  [SQLite Shared-Cache Mode]
  3899         -**
  3900         -** Requirements: [H10331] [H10336] [H10337] [H10339]
  3901   3961   */
  3902         -int sqlite3_enable_shared_cache(int);
         3962  +SQLITE_API int sqlite3_enable_shared_cache(int);
  3903   3963   
  3904   3964   /*
  3905         -** CAPI3REF: Attempt To Free Heap Memory {H17340} <S30220>
         3965  +** CAPI3REF: Attempt To Free Heap Memory
  3906   3966   **
  3907         -** The sqlite3_release_memory() interface attempts to free N bytes
         3967  +** ^The sqlite3_release_memory() interface attempts to free N bytes
  3908   3968   ** of heap memory by deallocating non-essential memory allocations
  3909         -** held by the database library. {END}  Memory used to cache database
         3969  +** held by the database library.   Memory used to cache database
  3910   3970   ** pages to improve performance is an example of non-essential memory.
  3911         -** sqlite3_release_memory() returns the number of bytes actually freed,
         3971  +** ^sqlite3_release_memory() returns the number of bytes actually freed,
  3912   3972   ** which might be more or less than the amount requested.
  3913         -**
  3914         -** Requirements: [H17341] [H17342]
  3915   3973   */
  3916         -int sqlite3_release_memory(int);
         3974  +SQLITE_API int sqlite3_release_memory(int);
  3917   3975   
  3918   3976   /*
  3919         -** CAPI3REF: Impose A Limit On Heap Size {H17350} <S30220>
         3977  +** CAPI3REF: Impose A Limit On Heap Size
  3920   3978   **
  3921         -** The sqlite3_soft_heap_limit() interface places a "soft" limit
         3979  +** ^The sqlite3_soft_heap_limit() interface places a "soft" limit
  3922   3980   ** on the amount of heap memory that may be allocated by SQLite.
  3923         -** If an internal allocation is requested that would exceed the
         3981  +** ^If an internal allocation is requested that would exceed the
  3924   3982   ** soft heap limit, [sqlite3_release_memory()] is invoked one or
  3925   3983   ** more times to free up some space before the allocation is performed.
  3926   3984   **
  3927         -** The limit is called "soft", because if [sqlite3_release_memory()]
         3985  +** ^The limit is called "soft" because if [sqlite3_release_memory()]
  3928   3986   ** cannot free sufficient memory to prevent the limit from being exceeded,
  3929   3987   ** the memory is allocated anyway and the current operation proceeds.
  3930   3988   **
  3931         -** A negative or zero value for N means that there is no soft heap limit and
         3989  +** ^A negative or zero value for N means that there is no soft heap limit and
  3932   3990   ** [sqlite3_release_memory()] will only be called when memory is exhausted.
  3933         -** The default value for the soft heap limit is zero.
         3991  +** ^The default value for the soft heap limit is zero.
  3934   3992   **
  3935         -** SQLite makes a best effort to honor the soft heap limit.
         3993  +** ^(SQLite makes a best effort to honor the soft heap limit.
  3936   3994   ** But if the soft heap limit cannot be honored, execution will
  3937         -** continue without error or notification.  This is why the limit is
         3995  +** continue without error or notification.)^  This is why the limit is
  3938   3996   ** called a "soft" limit.  It is advisory only.
  3939   3997   **
  3940   3998   ** Prior to SQLite version 3.5.0, this routine only constrained the memory
  3941   3999   ** allocated by a single thread - the same thread in which this routine
  3942   4000   ** runs.  Beginning with SQLite version 3.5.0, the soft heap limit is
  3943   4001   ** applied to all threads. The value specified for the soft heap limit
  3944   4002   ** is an upper bound on the total memory allocation for all threads. In
  3945   4003   ** version 3.5.0 there is no mechanism for limiting the heap usage for
  3946   4004   ** individual threads.
  3947         -**
  3948         -** Requirements:
  3949         -** [H16351] [H16352] [H16353] [H16354] [H16355] [H16358]
  3950   4005   */
  3951         -void sqlite3_soft_heap_limit(int);
         4006  +SQLITE_API void sqlite3_soft_heap_limit(int);
  3952   4007   
  3953   4008   /*
  3954         -** CAPI3REF: Extract Metadata About A Column Of A Table {H12850} <S60300>
         4009  +** CAPI3REF: Extract Metadata About A Column Of A Table
  3955   4010   **
  3956         -** This routine returns metadata about a specific column of a specific
         4011  +** ^This routine returns metadata about a specific column of a specific
  3957   4012   ** database table accessible using the [database connection] handle
  3958   4013   ** passed as the first function argument.
  3959   4014   **
  3960         -** The column is identified by the second, third and fourth parameters to
  3961         -** this function. The second parameter is either the name of the database
  3962         -** (i.e. "main", "temp" or an attached database) containing the specified
  3963         -** table or NULL. If it is NULL, then all attached databases are searched
         4015  +** ^The column is identified by the second, third and fourth parameters to
         4016  +** this function. ^The second parameter is either the name of the database
         4017  +** (i.e. "main", "temp", or an attached database) containing the specified
         4018  +** table or NULL. ^If it is NULL, then all attached databases are searched
  3964   4019   ** for the table using the same algorithm used by the database engine to
  3965   4020   ** resolve unqualified table references.
  3966   4021   **
  3967         -** The third and fourth parameters to this function are the table and column
         4022  +** ^The third and fourth parameters to this function are the table and column
  3968   4023   ** name of the desired column, respectively. Neither of these parameters
  3969   4024   ** may be NULL.
  3970   4025   **
  3971         -** Metadata is returned by writing to the memory locations passed as the 5th
  3972         -** and subsequent parameters to this function. Any of these arguments may be
         4026  +** ^Metadata is returned by writing to the memory locations passed as the 5th
         4027  +** and subsequent parameters to this function. ^Any of these arguments may be
  3973   4028   ** NULL, in which case the corresponding element of metadata is omitted.
  3974   4029   **
  3975         -** <blockquote>
         4030  +** ^(<blockquote>
  3976   4031   ** <table border="1">
  3977   4032   ** <tr><th> Parameter <th> Output<br>Type <th>  Description
  3978   4033   **
  3979   4034   ** <tr><td> 5th <td> const char* <td> Data type
  3980   4035   ** <tr><td> 6th <td> const char* <td> Name of default collation sequence
  3981   4036   ** <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
  3982   4037   ** <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
  3983   4038   ** <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
  3984   4039   ** </table>
  3985         -** </blockquote>
         4040  +** </blockquote>)^
  3986   4041   **
  3987         -** The memory pointed to by the character pointers returned for the
         4042  +** ^The memory pointed to by the character pointers returned for the
  3988   4043   ** declaration type and collation sequence is valid only until the next
  3989   4044   ** call to any SQLite API function.
  3990   4045   **
  3991         -** If the specified table is actually a view, an [error code] is returned.
         4046  +** ^If the specified table is actually a view, an [error code] is returned.
  3992   4047   **
  3993         -** If the specified column is "rowid", "oid" or "_rowid_" and an
         4048  +** ^If the specified column is "rowid", "oid" or "_rowid_" and an
  3994   4049   ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
  3995         -** parameters are set for the explicitly declared column. If there is no
         4050  +** parameters are set for the explicitly declared column. ^(If there is no
  3996   4051   ** explicitly declared [INTEGER PRIMARY KEY] column, then the output
  3997   4052   ** parameters are set as follows:
  3998   4053   **
  3999   4054   ** <pre>
  4000   4055   **     data type: "INTEGER"
  4001   4056   **     collation sequence: "BINARY"
  4002   4057   **     not null: 0
  4003   4058   **     primary key: 1
  4004   4059   **     auto increment: 0
  4005         -** </pre>
         4060  +** </pre>)^
  4006   4061   **
  4007         -** This function may load one or more schemas from database files. If an
         4062  +** ^(This function may load one or more schemas from database files. If an
  4008   4063   ** error occurs during this process, or if the requested table or column
  4009   4064   ** cannot be found, an [error code] is returned and an error message left
  4010         -** in the [database connection] (to be retrieved using sqlite3_errmsg()).
         4065  +** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
  4011   4066   **
  4012         -** This API is only available if the library was compiled with the
         4067  +** ^This API is only available if the library was compiled with the
  4013   4068   ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
  4014   4069   */
  4015         -int sqlite3_table_column_metadata(
         4070  +SQLITE_API int sqlite3_table_column_metadata(
  4016   4071     sqlite3 *db,                /* Connection handle */
  4017   4072     const char *zDbName,        /* Database name or NULL */
  4018   4073     const char *zTableName,     /* Table name */
  4019   4074     const char *zColumnName,    /* Column name */
  4020   4075     char const **pzDataType,    /* OUTPUT: Declared data type */
  4021   4076     char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
  4022   4077     int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
  4023   4078     int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
  4024   4079     int *pAutoinc               /* OUTPUT: True if column is auto-increment */
  4025   4080   );
  4026   4081   
  4027   4082   /*
  4028         -** CAPI3REF: Load An Extension {H12600} <S20500>
  4029         -**
  4030         -** This interface loads an SQLite extension library from the named file.
  4031         -**
  4032         -** {H12601} The sqlite3_load_extension() interface attempts to load an
  4033         -**          SQLite extension library contained in the file zFile.
  4034         -**
  4035         -** {H12602} The entry point is zProc.
  4036         -**
  4037         -** {H12603} zProc may be 0, in which case the name of the entry point
  4038         -**          defaults to "sqlite3_extension_init".
  4039         -**
  4040         -** {H12604} The sqlite3_load_extension() interface shall return
  4041         -**          [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
  4042         -**
  4043         -** {H12605} If an error occurs and pzErrMsg is not 0, then the
  4044         -**          [sqlite3_load_extension()] interface shall attempt to
  4045         -**          fill *pzErrMsg with error message text stored in memory
  4046         -**          obtained from [sqlite3_malloc()]. {END}  The calling function
  4047         -**          should free this memory by calling [sqlite3_free()].
  4048         -**
  4049         -** {H12606} Extension loading must be enabled using
  4050         -**          [sqlite3_enable_load_extension()] prior to calling this API,
  4051         -**          otherwise an error will be returned.
  4052         -*/
  4053         -int sqlite3_load_extension(
         4083  +** CAPI3REF: Load An Extension
         4084  +**
         4085  +** ^This interface loads an SQLite extension library from the named file.
         4086  +**
         4087  +** ^The sqlite3_load_extension() interface attempts to load an
         4088  +** SQLite extension library contained in the file zFile.
         4089  +**
         4090  +** ^The entry point is zProc.
         4091  +** ^zProc may be 0, in which case the name of the entry point
         4092  +** defaults to "sqlite3_extension_init".
         4093  +** ^The sqlite3_load_extension() interface returns
         4094  +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
         4095  +** ^If an error occurs and pzErrMsg is not 0, then the
         4096  +** [sqlite3_load_extension()] interface shall attempt to
         4097  +** fill *pzErrMsg with error message text stored in memory
         4098  +** obtained from [sqlite3_malloc()]. The calling function
         4099  +** should free this memory by calling [sqlite3_free()].
         4100  +**
         4101  +** ^Extension loading must be enabled using
         4102  +** [sqlite3_enable_load_extension()] prior to calling this API,
         4103  +** otherwise an error will be returned.
         4104  +**
         4105  +** See also the [load_extension() SQL function].
         4106  +*/
         4107  +SQLITE_API int sqlite3_load_extension(
  4054   4108     sqlite3 *db,          /* Load the extension into this database connection */
  4055   4109     const char *zFile,    /* Name of the shared library containing extension */
  4056   4110     const char *zProc,    /* Entry point.  Derived from zFile if 0 */
  4057   4111     char **pzErrMsg       /* Put error message here if not 0 */
  4058   4112   );
  4059   4113   
  4060   4114   /*
  4061         -** CAPI3REF: Enable Or Disable Extension Loading {H12620} <S20500>
         4115  +** CAPI3REF: Enable Or Disable Extension Loading
  4062   4116   **
  4063         -** So as not to open security holes in older applications that are
         4117  +** ^So as not to open security holes in older applications that are
  4064   4118   ** unprepared to deal with extension loading, and as a means of disabling
  4065   4119   ** extension loading while evaluating user-entered SQL, the following API
  4066   4120   ** is provided to turn the [sqlite3_load_extension()] mechanism on and off.
  4067   4121   **
  4068         -** Extension loading is off by default. See ticket #1863.
  4069         -**
  4070         -** {H12621} Call the sqlite3_enable_load_extension() routine with onoff==1
  4071         -**          to turn extension loading on and call it with onoff==0 to turn
  4072         -**          it back off again.
  4073         -**
  4074         -** {H12622} Extension loading is off by default.
         4122  +** ^Extension loading is off by default. See ticket #1863.
         4123  +** ^Call the sqlite3_enable_load_extension() routine with onoff==1
         4124  +** to turn extension loading on and call it with onoff==0 to turn
         4125  +** it back off again.
  4075   4126   */
  4076         -int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
         4127  +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
  4077   4128   
  4078   4129   /*
  4079         -** CAPI3REF: Automatically Load An Extensions {H12640} <S20500>
         4130  +** CAPI3REF: Automatically Load An Extensions
  4080   4131   **
  4081         -** This API can be invoked at program startup in order to register
         4132  +** ^This API can be invoked at program startup in order to register
  4082   4133   ** one or more statically linked extensions that will be available
  4083         -** to all new [database connections]. {END}
  4084         -**
  4085         -** This routine stores a pointer to the extension in an array that is
  4086         -** obtained from [sqlite3_malloc()].  If you run a memory leak checker
  4087         -** on your program and it reports a leak because of this array, invoke
  4088         -** [sqlite3_reset_auto_extension()] prior to shutdown to free the memory.
  4089         -**
  4090         -** {H12641} This function registers an extension entry point that is
  4091         -**          automatically invoked whenever a new [database connection]
  4092         -**          is opened using [sqlite3_open()], [sqlite3_open16()],
  4093         -**          or [sqlite3_open_v2()].
  4094         -**
  4095         -** {H12642} Duplicate extensions are detected so calling this routine
  4096         -**          multiple times with the same extension is harmless.
  4097         -**
  4098         -** {H12643} This routine stores a pointer to the extension in an array
  4099         -**          that is obtained from [sqlite3_malloc()].
  4100         -**
  4101         -** {H12644} Automatic extensions apply across all threads.
  4102         -*/
  4103         -int sqlite3_auto_extension(void (*xEntryPoint)(void));
  4104         -
  4105         -/*
  4106         -** CAPI3REF: Reset Automatic Extension Loading {H12660} <S20500>
  4107         -**
  4108         -** This function disables all previously registered automatic
  4109         -** extensions. {END}  It undoes the effect of all prior
  4110         -** [sqlite3_auto_extension()] calls.
  4111         -**
  4112         -** {H12661} This function disables all previously registered
  4113         -**          automatic extensions.
  4114         -**
  4115         -** {H12662} This function disables automatic extensions in all threads.
  4116         -*/
  4117         -void sqlite3_reset_auto_extension(void);
         4134  +** to all new [database connections].
         4135  +**
         4136  +** ^(This routine stores a pointer to the extension entry point
         4137  +** in an array that is obtained from [sqlite3_malloc()].  That memory
         4138  +** is deallocated by [sqlite3_reset_auto_extension()].)^
         4139  +**
         4140  +** ^This function registers an extension entry point that is
         4141  +** automatically invoked whenever a new [database connection]
         4142  +** is opened using [sqlite3_open()], [sqlite3_open16()],
         4143  +** or [sqlite3_open_v2()].
         4144  +** ^Duplicate extensions are detected so calling this routine
         4145  +** multiple times with the same extension is harmless.
         4146  +** ^Automatic extensions apply across all threads.
         4147  +*/
         4148  +SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
         4149  +
         4150  +/*
         4151  +** CAPI3REF: Reset Automatic Extension Loading
         4152  +**
         4153  +** ^(This function disables all previously registered automatic
         4154  +** extensions. It undoes the effect of all prior
         4155  +** [sqlite3_auto_extension()] calls.)^
         4156  +**
         4157  +** ^This function disables automatic extensions in all threads.
         4158  +*/
         4159  +SQLITE_API void sqlite3_reset_auto_extension(void);
  4118   4160   
  4119   4161   /*
  4120   4162   ****** EXPERIMENTAL - subject to change without notice **************
  4121   4163   **
  4122   4164   ** The interface to the virtual-table mechanism is currently considered
  4123   4165   ** to be experimental.  The interface might change in incompatible ways.
  4124   4166   ** If this is a problem for you, do not use the interface at this time.
................................................................................
  4132   4174   */
  4133   4175   typedef struct sqlite3_vtab sqlite3_vtab;
  4134   4176   typedef struct sqlite3_index_info sqlite3_index_info;
  4135   4177   typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
  4136   4178   typedef struct sqlite3_module sqlite3_module;
  4137   4179   
  4138   4180   /*
  4139         -** CAPI3REF: Virtual Table Object {H18000} <S20400>
         4181  +** CAPI3REF: Virtual Table Object
  4140   4182   ** KEYWORDS: sqlite3_module {virtual table module}
  4141   4183   ** EXPERIMENTAL
  4142   4184   **
  4143   4185   ** This structure, sometimes called a a "virtual table module", 
  4144   4186   ** defines the implementation of a [virtual tables].  
  4145   4187   ** This structure consists mostly of methods for the module.
  4146   4188   **
  4147         -** A virtual table module is created by filling in a persistent
         4189  +** ^A virtual table module is created by filling in a persistent
  4148   4190   ** instance of this structure and passing a pointer to that instance
  4149   4191   ** to [sqlite3_create_module()] or [sqlite3_create_module_v2()].
  4150         -** The registration remains valid until it is replaced by a different
         4192  +** ^The registration remains valid until it is replaced by a different
  4151   4193   ** module or until the [database connection] closes.  The content
  4152   4194   ** of this structure must not change while it is registered with
  4153   4195   ** any database connection.
  4154   4196   */
  4155   4197   struct sqlite3_module {
  4156   4198     int iVersion;
  4157   4199     int (*xCreate)(sqlite3*, void *pAux,
................................................................................
  4179   4221     int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
  4180   4222                          void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
  4181   4223                          void **ppArg);
  4182   4224     int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
  4183   4225   };
  4184   4226   
  4185   4227   /*
  4186         -** CAPI3REF: Virtual Table Indexing Information {H18100} <S20400>
         4228  +** CAPI3REF: Virtual Table Indexing Information
  4187   4229   ** KEYWORDS: sqlite3_index_info
  4188   4230   ** EXPERIMENTAL
  4189   4231   **
  4190   4232   ** The sqlite3_index_info structure and its substructures is used to
  4191   4233   ** pass information into and receive the reply from the [xBestIndex]
  4192   4234   ** method of a [virtual table module].  The fields under **Inputs** are the
  4193   4235   ** inputs to xBestIndex and are read-only.  xBestIndex inserts its
  4194   4236   ** results into the **Outputs** fields.
  4195   4237   **
  4196         -** The aConstraint[] array records WHERE clause constraints of the form:
         4238  +** ^(The aConstraint[] array records WHERE clause constraints of the form:
  4197   4239   **
  4198   4240   ** <pre>column OP expr</pre>
  4199   4241   **
  4200         -** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.  The particular operator is
  4201         -** stored in aConstraint[].op.  The index of the column is stored in
  4202         -** aConstraint[].iColumn.  aConstraint[].usable is TRUE if the
         4242  +** where OP is =, &lt;, &lt;=, &gt;, or &gt;=.)^  ^(The particular operator is
         4243  +** stored in aConstraint[].op.)^  ^(The index of the column is stored in
         4244  +** aConstraint[].iColumn.)^  ^(aConstraint[].usable is TRUE if the
  4203   4245   ** expr on the right-hand side can be evaluated (and thus the constraint
  4204         -** is usable) and false if it cannot.
         4246  +** is usable) and false if it cannot.)^
  4205   4247   **
  4206         -** The optimizer automatically inverts terms of the form "expr OP column"
         4248  +** ^The optimizer automatically inverts terms of the form "expr OP column"
  4207   4249   ** and makes other simplifications to the WHERE clause in an attempt to
  4208   4250   ** get as many WHERE clause terms into the form shown above as possible.
  4209         -** The aConstraint[] array only reports WHERE clause terms in the correct
  4210         -** form that refer to the particular virtual table being queried.
         4251  +** ^The aConstraint[] array only reports WHERE clause terms that are
         4252  +** relevant to the particular virtual table being queried.
  4211   4253   **
  4212         -** Information about the ORDER BY clause is stored in aOrderBy[].
  4213         -** Each term of aOrderBy records a column of the ORDER BY clause.
         4254  +** ^Information about the ORDER BY clause is stored in aOrderBy[].
         4255  +** ^Each term of aOrderBy records a column of the ORDER BY clause.
  4214   4256   **
  4215   4257   ** The [xBestIndex] method must fill aConstraintUsage[] with information
  4216         -** about what parameters to pass to xFilter.  If argvIndex>0 then
         4258  +** about what parameters to pass to xFilter.  ^If argvIndex>0 then
  4217   4259   ** the right-hand side of the corresponding aConstraint[] is evaluated
  4218         -** and becomes the argvIndex-th entry in argv.  If aConstraintUsage[].omit
         4260  +** and becomes the argvIndex-th entry in argv.  ^(If aConstraintUsage[].omit
  4219   4261   ** is true, then the constraint is assumed to be fully handled by the
  4220         -** virtual table and is not checked again by SQLite.
         4262  +** virtual table and is not checked again by SQLite.)^
  4221   4263   **
  4222         -** The idxNum and idxPtr values are recorded and passed into the
         4264  +** ^The idxNum and idxPtr values are recorded and passed into the
  4223   4265   ** [xFilter] method.
  4224         -** [sqlite3_free()] is used to free idxPtr if and only iff
         4266  +** ^[sqlite3_free()] is used to free idxPtr if and only if
  4225   4267   ** needToFreeIdxPtr is true.
  4226   4268   **
  4227         -** The orderByConsumed means that output from [xFilter]/[xNext] will occur in
         4269  +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
  4228   4270   ** the correct order to satisfy the ORDER BY clause so that no separate
  4229   4271   ** sorting step is required.
  4230   4272   **
  4231         -** The estimatedCost value is an estimate of the cost of doing the
         4273  +** ^The estimatedCost value is an estimate of the cost of doing the
  4232   4274   ** particular lookup.  A full scan of a table with N entries should have
  4233   4275   ** a cost of N.  A binary search of a table of N entries should have a
  4234   4276   ** cost of approximately log(N).
  4235   4277   */
  4236   4278   struct sqlite3_index_info {
  4237   4279     /* Inputs */
  4238   4280     int nConstraint;           /* Number of entries in aConstraint */
................................................................................
  4262   4304   #define SQLITE_INDEX_CONSTRAINT_GT    4
  4263   4305   #define SQLITE_INDEX_CONSTRAINT_LE    8
  4264   4306   #define SQLITE_INDEX_CONSTRAINT_LT    16
  4265   4307   #define SQLITE_INDEX_CONSTRAINT_GE    32
  4266   4308   #define SQLITE_INDEX_CONSTRAINT_MATCH 64
  4267   4309   
  4268   4310   /*
  4269         -** CAPI3REF: Register A Virtual Table Implementation {H18200} <S20400>
         4311  +** CAPI3REF: Register A Virtual Table Implementation
  4270   4312   ** EXPERIMENTAL
  4271   4313   **
  4272         -** This routine is used to register a new [virtual table module] name.
  4273         -** Module names must be registered before
  4274         -** creating a new [virtual table] using the module, or before using a
         4314  +** ^These routines are used to register a new [virtual table module] name.
         4315  +** ^Module names must be registered before
         4316  +** creating a new [virtual table] using the module and before using a
  4275   4317   ** preexisting [virtual table] for the module.
  4276   4318   **
  4277         -** The module name is registered on the [database connection] specified
  4278         -** by the first parameter.  The name of the module is given by the 
  4279         -** second parameter.  The third parameter is a pointer to
  4280         -** the implementation of the [virtual table module].   The fourth
         4319  +** ^The module name is registered on the [database connection] specified
         4320  +** by the first parameter.  ^The name of the module is given by the 
         4321  +** second parameter.  ^The third parameter is a pointer to
         4322  +** the implementation of the [virtual table module].   ^The fourth
  4281   4323   ** parameter is an arbitrary client data pointer that is passed through
  4282   4324   ** into the [xCreate] and [xConnect] methods of the virtual table module
  4283   4325   ** when a new virtual table is be being created or reinitialized.
  4284   4326   **
  4285         -** This interface has exactly the same effect as calling
  4286         -** [sqlite3_create_module_v2()] with a NULL client data destructor.
         4327  +** ^The sqlite3_create_module_v2() interface has a fifth parameter which
         4328  +** is a pointer to a destructor for the pClientData.  ^SQLite will
         4329  +** invoke the destructor function (if it is not NULL) when SQLite
         4330  +** no longer needs the pClientData pointer.  ^The sqlite3_create_module()
         4331  +** interface is equivalent to sqlite3_create_module_v2() with a NULL
         4332  +** destructor.
  4287   4333   */
  4288         -SQLITE_EXPERIMENTAL int sqlite3_create_module(
         4334  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module(
  4289   4335     sqlite3 *db,               /* SQLite connection to register module with */
  4290   4336     const char *zName,         /* Name of the module */
  4291   4337     const sqlite3_module *p,   /* Methods for the module */
  4292   4338     void *pClientData          /* Client data for xCreate/xConnect */
  4293   4339   );
  4294         -
  4295         -/*
  4296         -** CAPI3REF: Register A Virtual Table Implementation {H18210} <S20400>
  4297         -** EXPERIMENTAL
  4298         -**
  4299         -** This routine is identical to the [sqlite3_create_module()] method,
  4300         -** except that it has an extra parameter to specify 
  4301         -** a destructor function for the client data pointer.  SQLite will
  4302         -** invoke the destructor function (if it is not NULL) when SQLite
  4303         -** no longer needs the pClientData pointer.  
  4304         -*/
  4305         -SQLITE_EXPERIMENTAL int sqlite3_create_module_v2(
         4340  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_create_module_v2(
  4306   4341     sqlite3 *db,               /* SQLite connection to register module with */
  4307   4342     const char *zName,         /* Name of the module */
  4308   4343     const sqlite3_module *p,   /* Methods for the module */
  4309   4344     void *pClientData,         /* Client data for xCreate/xConnect */
  4310   4345     void(*xDestroy)(void*)     /* Module destructor function */
  4311   4346   );
  4312   4347   
  4313   4348   /*
  4314         -** CAPI3REF: Virtual Table Instance Object {H18010} <S20400>
         4349  +** CAPI3REF: Virtual Table Instance Object
  4315   4350   ** KEYWORDS: sqlite3_vtab
  4316   4351   ** EXPERIMENTAL
  4317   4352   **
  4318   4353   ** Every [virtual table module] implementation uses a subclass
  4319         -** of the following structure to describe a particular instance
         4354  +** of this object to describe a particular instance
  4320   4355   ** of the [virtual table].  Each subclass will
  4321   4356   ** be tailored to the specific needs of the module implementation.
  4322   4357   ** The purpose of this superclass is to define certain fields that are
  4323   4358   ** common to all module implementations.
  4324   4359   **
  4325         -** Virtual tables methods can set an error message by assigning a
         4360  +** ^Virtual tables methods can set an error message by assigning a
  4326   4361   ** string obtained from [sqlite3_mprintf()] to zErrMsg.  The method should
  4327   4362   ** take care that any prior string is freed by a call to [sqlite3_free()]
  4328         -** prior to assigning a new string to zErrMsg.  After the error message
         4363  +** prior to assigning a new string to zErrMsg.  ^After the error message
  4329   4364   ** is delivered up to the client application, the string will be automatically
  4330   4365   ** freed by sqlite3_free() and the zErrMsg field will be zeroed.
  4331   4366   */
  4332   4367   struct sqlite3_vtab {
  4333   4368     const sqlite3_module *pModule;  /* The module for this virtual table */
  4334         -  int nRef;                       /* Used internally */
         4369  +  int nRef;                       /* NO LONGER USED */
  4335   4370     char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
  4336   4371     /* Virtual table implementations will typically add additional fields */
  4337   4372   };
  4338   4373   
  4339   4374   /*
  4340         -** CAPI3REF: Virtual Table Cursor Object  {H18020} <S20400>
         4375  +** CAPI3REF: Virtual Table Cursor Object
  4341   4376   ** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor}
  4342   4377   ** EXPERIMENTAL
  4343   4378   **
  4344   4379   ** Every [virtual table module] implementation uses a subclass of the
  4345   4380   ** following structure to describe cursors that point into the
  4346   4381   ** [virtual table] and are used
  4347   4382   ** to loop through the virtual table.  Cursors are created using the
  4348   4383   ** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed
  4349         -** by the [sqlite3_module.xClose | xClose] method.  Cussors are used
         4384  +** by the [sqlite3_module.xClose | xClose] method.  Cursors are used
  4350   4385   ** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods
  4351   4386   ** of the module.  Each module implementation will define
  4352   4387   ** the content of a cursor structure to suit its own needs.
  4353   4388   **
  4354   4389   ** This superclass exists in order to define fields of the cursor that
  4355   4390   ** are common to all implementations.
  4356   4391   */
  4357   4392   struct sqlite3_vtab_cursor {
  4358   4393     sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
  4359   4394     /* Virtual table implementations will typically add additional fields */
  4360   4395   };
  4361   4396   
  4362   4397   /*
  4363         -** CAPI3REF: Declare The Schema Of A Virtual Table {H18280} <S20400>
         4398  +** CAPI3REF: Declare The Schema Of A Virtual Table
  4364   4399   ** EXPERIMENTAL
  4365   4400   **
  4366         -** The [xCreate] and [xConnect] methods of a
         4401  +** ^The [xCreate] and [xConnect] methods of a
  4367   4402   ** [virtual table module] call this interface
  4368   4403   ** to declare the format (the names and datatypes of the columns) of
  4369   4404   ** the virtual tables they implement.
  4370   4405   */
  4371         -SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
         4406  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
  4372   4407   
  4373   4408   /*
  4374         -** CAPI3REF: Overload A Function For A Virtual Table {H18300} <S20400>
         4409  +** CAPI3REF: Overload A Function For A Virtual Table
  4375   4410   ** EXPERIMENTAL
  4376   4411   **
  4377         -** Virtual tables can provide alternative implementations of functions
         4412  +** ^(Virtual tables can provide alternative implementations of functions
  4378   4413   ** using the [xFindFunction] method of the [virtual table module].  
  4379   4414   ** But global versions of those functions
  4380         -** must exist in order to be overloaded.
         4415  +** must exist in order to be overloaded.)^
  4381   4416   **
  4382         -** This API makes sure a global version of a function with a particular
         4417  +** ^(This API makes sure a global version of a function with a particular
  4383   4418   ** name and number of parameters exists.  If no such function exists
  4384         -** before this API is called, a new function is created.  The implementation
         4419  +** before this API is called, a new function is created.)^  ^The implementation
  4385   4420   ** of the new function always causes an exception to be thrown.  So
  4386   4421   ** the new function is not good for anything by itself.  Its only
  4387   4422   ** purpose is to be a placeholder function that can be overloaded
  4388   4423   ** by a [virtual table].
  4389   4424   */
  4390         -SQLITE_EXPERIMENTAL int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
         4425  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
  4391   4426   
  4392   4427   /*
  4393   4428   ** The interface to the virtual-table mechanism defined above (back up
  4394   4429   ** to a comment remarkably similar to this one) is currently considered
  4395   4430   ** to be experimental.  The interface might change in incompatible ways.
  4396   4431   ** If this is a problem for you, do not use the interface at this time.
  4397   4432   **
................................................................................
  4398   4433   ** When the virtual-table mechanism stabilizes, we will declare the
  4399   4434   ** interface fixed, support it indefinitely, and remove this comment.
  4400   4435   **
  4401   4436   ****** EXPERIMENTAL - subject to change without notice **************
  4402   4437   */
  4403   4438   
  4404   4439   /*
  4405         -** CAPI3REF: A Handle To An Open BLOB {H17800} <S30230>
         4440  +** CAPI3REF: A Handle To An Open BLOB
  4406   4441   ** KEYWORDS: {BLOB handle} {BLOB handles}
  4407   4442   **
  4408   4443   ** An instance of this object represents an open BLOB on which
  4409   4444   ** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
  4410         -** Objects of this type are created by [sqlite3_blob_open()]
         4445  +** ^Objects of this type are created by [sqlite3_blob_open()]
  4411   4446   ** and destroyed by [sqlite3_blob_close()].
  4412         -** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
         4447  +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
  4413   4448   ** can be used to read or write small subsections of the BLOB.
  4414         -** The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
         4449  +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
  4415   4450   */
  4416   4451   typedef struct sqlite3_blob sqlite3_blob;
  4417   4452   
  4418   4453   /*
  4419         -** CAPI3REF: Open A BLOB For Incremental I/O {H17810} <S30230>
         4454  +** CAPI3REF: Open A BLOB For Incremental I/O
  4420   4455   **
  4421         -** This interfaces opens a [BLOB handle | handle] to the BLOB located
         4456  +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
  4422   4457   ** in row iRow, column zColumn, table zTable in database zDb;
  4423   4458   ** in other words, the same BLOB that would be selected by:
  4424   4459   **
  4425   4460   ** <pre>
  4426   4461   **     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
  4427         -** </pre> {END}
         4462  +** </pre>)^
  4428   4463   **
  4429         -** If the flags parameter is non-zero, then the BLOB is opened for read
  4430         -** and write access. If it is zero, the BLOB is opened for read access.
         4464  +** ^If the flags parameter is non-zero, then the BLOB is opened for read
         4465  +** and write access. ^If it is zero, the BLOB is opened for read access.
         4466  +** ^It is not possible to open a column that is part of an index or primary 
         4467  +** key for writing. ^If [foreign key constraints] are enabled, it is 
         4468  +** not possible to open a column that is part of a [child key] for writing.
  4431   4469   **
  4432         -** Note that the database name is not the filename that contains
         4470  +** ^Note that the database name is not the filename that contains
  4433   4471   ** the database but rather the symbolic name of the database that
  4434         -** is assigned when the database is connected using [ATTACH].
  4435         -** For the main database file, the database name is "main".
  4436         -** For TEMP tables, the database name is "temp".
         4472  +** appears after the AS keyword when the database is connected using [ATTACH].
         4473  +** ^For the main database file, the database name is "main".
         4474  +** ^For TEMP tables, the database name is "temp".
  4437   4475   **
  4438         -** On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
         4476  +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
  4439   4477   ** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set
  4440         -** to be a null pointer.
  4441         -** This function sets the [database connection] error code and message
         4478  +** to be a null pointer.)^
         4479  +** ^This function sets the [database connection] error code and message
  4442   4480   ** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related
  4443         -** functions.  Note that the *ppBlob variable is always initialized in a
         4481  +** functions. ^Note that the *ppBlob variable is always initialized in a
  4444   4482   ** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob
  4445   4483   ** regardless of the success or failure of this routine.
  4446   4484   **
  4447         -** If the row that a BLOB handle points to is modified by an
         4485  +** ^(If the row that a BLOB handle points to is modified by an
  4448   4486   ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
  4449   4487   ** then the BLOB handle is marked as "expired".
  4450   4488   ** This is true if any column of the row is changed, even a column
  4451         -** other than the one the BLOB handle is open on.
  4452         -** Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for
         4489  +** other than the one the BLOB handle is open on.)^
         4490  +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for
  4453   4491   ** a expired BLOB handle fail with an return code of [SQLITE_ABORT].
  4454         -** Changes written into a BLOB prior to the BLOB expiring are not
  4455         -** rollback by the expiration of the BLOB.  Such changes will eventually
  4456         -** commit if the transaction continues to completion.
         4492  +** ^(Changes written into a BLOB prior to the BLOB expiring are not
         4493  +** rolled back by the expiration of the BLOB.  Such changes will eventually
         4494  +** commit if the transaction continues to completion.)^
  4457   4495   **
  4458         -** Use the [sqlite3_blob_bytes()] interface to determine the size of
  4459         -** the opened blob.  The size of a blob may not be changed by this
  4460         -** underface.  Use the [UPDATE] SQL command to change the size of a
         4496  +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of
         4497  +** the opened blob.  ^The size of a blob may not be changed by this
         4498  +** interface.  Use the [UPDATE] SQL command to change the size of a
  4461   4499   ** blob.
  4462   4500   **
  4463         -** The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
         4501  +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
  4464   4502   ** and the built-in [zeroblob] SQL function can be used, if desired,
  4465   4503   ** to create an empty, zero-filled blob in which to read or write using
  4466   4504   ** this interface.
  4467   4505   **
  4468   4506   ** To avoid a resource leak, every open [BLOB handle] should eventually
  4469   4507   ** be released by a call to [sqlite3_blob_close()].
  4470         -**
  4471         -** Requirements:
  4472         -** [H17813] [H17814] [H17816] [H17819] [H17821] [H17824]
  4473   4508   */
  4474         -int sqlite3_blob_open(
         4509  +SQLITE_API int sqlite3_blob_open(
  4475   4510     sqlite3*,
  4476   4511     const char *zDb,
  4477   4512     const char *zTable,
  4478   4513     const char *zColumn,
  4479   4514     sqlite3_int64 iRow,
  4480   4515     int flags,
  4481   4516     sqlite3_blob **ppBlob
  4482   4517   );
  4483   4518   
  4484   4519   /*
  4485         -** CAPI3REF: Close A BLOB Handle {H17830} <S30230>
         4520  +** CAPI3REF: Close A BLOB Handle
  4486   4521   **
  4487         -** Closes an open [BLOB handle].
         4522  +** ^Closes an open [BLOB handle].
  4488   4523   **
  4489         -** Closing a BLOB shall cause the current transaction to commit
         4524  +** ^Closing a BLOB shall cause the current transaction to commit
  4490   4525   ** if there are no other BLOBs, no pending prepared statements, and the
  4491   4526   ** database connection is in [autocommit mode].
  4492         -** If any writes were made to the BLOB, they might be held in cache
         4527  +** ^If any writes were made to the BLOB, they might be held in cache
  4493   4528   ** until the close operation if they will fit.
  4494   4529   **
  4495         -** Closing the BLOB often forces the changes
         4530  +** ^(Closing the BLOB often forces the changes
  4496   4531   ** out to disk and so if any I/O errors occur, they will likely occur
  4497   4532   ** at the time when the BLOB is closed.  Any errors that occur during
  4498         -** closing are reported as a non-zero return value.
         4533  +** closing are reported as a non-zero return value.)^
  4499   4534   **
  4500         -** The BLOB is closed unconditionally.  Even if this routine returns
  4501         -** an error code, the BLOB is still closed.
         4535  +** ^(The BLOB is closed unconditionally.  Even if this routine returns
         4536  +** an error code, the BLOB is still closed.)^
  4502   4537   **
  4503         -** Calling this routine with a null pointer (which as would be returned
  4504         -** by failed call to [sqlite3_blob_open()]) is a harmless no-op.
  4505         -**
  4506         -** Requirements:
  4507         -** [H17833] [H17836] [H17839]
         4538  +** ^Calling this routine with a null pointer (such as would be returned
         4539  +** by a failed call to [sqlite3_blob_open()]) is a harmless no-op.
  4508   4540   */
  4509         -int sqlite3_blob_close(sqlite3_blob *);
         4541  +SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
  4510   4542   
  4511   4543   /*
  4512         -** CAPI3REF: Return The Size Of An Open BLOB {H17840} <S30230>
         4544  +** CAPI3REF: Return The Size Of An Open BLOB
  4513   4545   **
  4514         -** Returns the size in bytes of the BLOB accessible via the 
  4515         -** successfully opened [BLOB handle] in its only argument.  The
         4546  +** ^Returns the size in bytes of the BLOB accessible via the 
         4547  +** successfully opened [BLOB handle] in its only argument.  ^The
  4516   4548   ** incremental blob I/O routines can only read or overwriting existing
  4517   4549   ** blob content; they cannot change the size of a blob.
  4518   4550   **
  4519   4551   ** This routine only works on a [BLOB handle] which has been created
  4520   4552   ** by a prior successful call to [sqlite3_blob_open()] and which has not
  4521   4553   ** been closed by [sqlite3_blob_close()].  Passing any other pointer in
  4522   4554   ** to this routine results in undefined and probably undesirable behavior.
  4523         -**
  4524         -** Requirements:
  4525         -** [H17843]
  4526   4555   */
  4527         -int sqlite3_blob_bytes(sqlite3_blob *);
         4556  +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
  4528   4557   
  4529   4558   /*
  4530         -** CAPI3REF: Read Data From A BLOB Incrementally {H17850} <S30230>
         4559  +** CAPI3REF: Read Data From A BLOB Incrementally
  4531   4560   **
  4532         -** This function is used to read data from an open [BLOB handle] into a
         4561  +** ^(This function is used to read data from an open [BLOB handle] into a
  4533   4562   ** caller-supplied buffer. N bytes of data are copied into buffer Z
  4534         -** from the open BLOB, starting at offset iOffset.
         4563  +** from the open BLOB, starting at offset iOffset.)^
  4535   4564   **
  4536         -** If offset iOffset is less than N bytes from the end of the BLOB,
  4537         -** [SQLITE_ERROR] is returned and no data is read.  If N or iOffset is
         4565  +** ^If offset iOffset is less than N bytes from the end of the BLOB,
         4566  +** [SQLITE_ERROR] is returned and no data is read.  ^If N or iOffset is
  4538   4567   ** less than zero, [SQLITE_ERROR] is returned and no data is read.
  4539         -** The size of the blob (and hence the maximum value of N+iOffset)
         4568  +** ^The size of the blob (and hence the maximum value of N+iOffset)
  4540   4569   ** can be determined using the [sqlite3_blob_bytes()] interface.
  4541   4570   **
  4542         -** An attempt to read from an expired [BLOB handle] fails with an
         4571  +** ^An attempt to read from an expired [BLOB handle] fails with an
  4543   4572   ** error code of [SQLITE_ABORT].
  4544   4573   **
  4545         -** On success, SQLITE_OK is returned.
  4546         -** Otherwise, an [error code] or an [extended error code] is returned.
         4574  +** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
         4575  +** Otherwise, an [error code] or an [extended error code] is returned.)^
  4547   4576   **
  4548   4577   ** This routine only works on a [BLOB handle] which has been created
  4549   4578   ** by a prior successful call to [sqlite3_blob_open()] and which has not
  4550   4579   ** been closed by [sqlite3_blob_close()].  Passing any other pointer in
  4551   4580   ** to this routine results in undefined and probably undesirable behavior.
  4552   4581   **
  4553   4582   ** See also: [sqlite3_blob_write()].
  4554         -**
  4555         -** Requirements:
  4556         -** [H17853] [H17856] [H17859] [H17862] [H17863] [H17865] [H17868]
  4557   4583   */
  4558         -int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
         4584  +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
  4559   4585   
  4560   4586   /*
  4561         -** CAPI3REF: Write Data Into A BLOB Incrementally {H17870} <S30230>
         4587  +** CAPI3REF: Write Data Into A BLOB Incrementally
  4562   4588   **
  4563         -** This function is used to write data into an open [BLOB handle] from a
  4564         -** caller-supplied buffer. N bytes of data are copied from the buffer Z
         4589  +** ^This function is used to write data into an open [BLOB handle] from a
         4590  +** caller-supplied buffer. ^N bytes of data are copied from the buffer Z
  4565   4591   ** into the open BLOB, starting at offset iOffset.
  4566   4592   **
  4567         -** If the [BLOB handle] passed as the first argument was not opened for
         4593  +** ^If the [BLOB handle] passed as the first argument was not opened for
  4568   4594   ** writing (the flags parameter to [sqlite3_blob_open()] was zero),
  4569   4595   ** this function returns [SQLITE_READONLY].
  4570   4596   **
  4571         -** This function may only modify the contents of the BLOB; it is
         4597  +** ^This function may only modify the contents of the BLOB; it is
  4572   4598   ** not possible to increase the size of a BLOB using this API.
  4573         -** If offset iOffset is less than N bytes from the end of the BLOB,
  4574         -** [SQLITE_ERROR] is returned and no data is written.  If N is
         4599  +** ^If offset iOffset is less than N bytes from the end of the BLOB,
         4600  +** [SQLITE_ERROR] is returned and no data is written.  ^If N is
  4575   4601   ** less than zero [SQLITE_ERROR] is returned and no data is written.
  4576   4602   ** The size of the BLOB (and hence the maximum value of N+iOffset)
  4577   4603   ** can be determined using the [sqlite3_blob_bytes()] interface.
  4578   4604   **
  4579         -** An attempt to write to an expired [BLOB handle] fails with an
  4580         -** error code of [SQLITE_ABORT].  Writes to the BLOB that occurred
         4605  +** ^An attempt to write to an expired [BLOB handle] fails with an
         4606  +** error code of [SQLITE_ABORT].  ^Writes to the BLOB that occurred
  4581   4607   ** before the [BLOB handle] expired are not rolled back by the
  4582   4608   ** expiration of the handle, though of course those changes might
  4583   4609   ** have been overwritten by the statement that expired the BLOB handle
  4584   4610   ** or by other independent statements.
  4585   4611   **
  4586         -** On success, SQLITE_OK is returned.
  4587         -** Otherwise, an  [error code] or an [extended error code] is returned.
         4612  +** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
         4613  +** Otherwise, an  [error code] or an [extended error code] is returned.)^
  4588   4614   **
  4589   4615   ** This routine only works on a [BLOB handle] which has been created
  4590   4616   ** by a prior successful call to [sqlite3_blob_open()] and which has not
  4591   4617   ** been closed by [sqlite3_blob_close()].  Passing any other pointer in
  4592   4618   ** to this routine results in undefined and probably undesirable behavior.
  4593   4619   **
  4594   4620   ** See also: [sqlite3_blob_read()].
  4595         -**
  4596         -** Requirements:
  4597         -** [H17873] [H17874] [H17875] [H17876] [H17877] [H17879] [H17882] [H17885]
  4598         -** [H17888]
  4599   4621   */
  4600         -int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
         4622  +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
  4601   4623   
  4602   4624   /*
  4603         -** CAPI3REF: Virtual File System Objects {H11200} <S20100>
         4625  +** CAPI3REF: Virtual File System Objects
  4604   4626   **
  4605   4627   ** A virtual filesystem (VFS) is an [sqlite3_vfs] object
  4606   4628   ** that SQLite uses to interact
  4607   4629   ** with the underlying operating system.  Most SQLite builds come with a
  4608   4630   ** single default VFS that is appropriate for the host computer.
  4609   4631   ** New VFSes can be registered and existing VFSes can be unregistered.
  4610   4632   ** The following interfaces are provided.
  4611   4633   **
  4612         -** The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
  4613         -** Names are case sensitive.
  4614         -** Names are zero-terminated UTF-8 strings.
  4615         -** If there is no match, a NULL pointer is returned.
  4616         -** If zVfsName is NULL then the default VFS is returned.
         4634  +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
         4635  +** ^Names are case sensitive.
         4636  +** ^Names are zero-terminated UTF-8 strings.
         4637  +** ^If there is no match, a NULL pointer is returned.
         4638  +** ^If zVfsName is NULL then the default VFS is returned.
  4617   4639   **
  4618         -** New VFSes are registered with sqlite3_vfs_register().
  4619         -** Each new VFS becomes the default VFS if the makeDflt flag is set.
  4620         -** The same VFS can be registered multiple times without injury.
  4621         -** To make an existing VFS into the default VFS, register it again
         4640  +** ^New VFSes are registered with sqlite3_vfs_register().
         4641  +** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
         4642  +** ^The same VFS can be registered multiple times without injury.
         4643  +** ^To make an existing VFS into the default VFS, register it again
  4622   4644   ** with the makeDflt flag set.  If two different VFSes with the
  4623   4645   ** same name are registered, the behavior is undefined.  If a
  4624   4646   ** VFS is registered with a name that is NULL or an empty string,
  4625   4647   ** then the behavior is undefined.
  4626   4648   **
  4627         -** Unregister a VFS with the sqlite3_vfs_unregister() interface.
  4628         -** If the default VFS is unregistered, another VFS is chosen as
  4629         -** the default.  The choice for the new VFS is arbitrary.
  4630         -**
  4631         -** Requirements:
  4632         -** [H11203] [H11206] [H11209] [H11212] [H11215] [H11218]
         4649  +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface.
         4650  +** ^(If the default VFS is unregistered, another VFS is chosen as
         4651  +** the default.  The choice for the new VFS is arbitrary.)^
  4633   4652   */
  4634         -sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
  4635         -int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
  4636         -int sqlite3_vfs_unregister(sqlite3_vfs*);
         4653  +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
         4654  +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
         4655  +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
  4637   4656   
  4638   4657   /*
  4639         -** CAPI3REF: Mutexes {H17000} <S20000>
         4658  +** CAPI3REF: Mutexes
  4640   4659   **
  4641   4660   ** The SQLite core uses these routines for thread
  4642   4661   ** synchronization. Though they are intended for internal
  4643   4662   ** use by SQLite, code that links against SQLite is
  4644   4663   ** permitted to use any of these routines.
  4645   4664   **
  4646   4665   ** The SQLite source code contains multiple implementations
  4647   4666   ** of these mutex routines.  An appropriate implementation
  4648         -** is selected automatically at compile-time.  The following
         4667  +** is selected automatically at compile-time.  ^(The following
  4649   4668   ** implementations are available in the SQLite core:
  4650   4669   **
  4651   4670   ** <ul>
  4652   4671   ** <li>   SQLITE_MUTEX_OS2
  4653   4672   ** <li>   SQLITE_MUTEX_PTHREAD
  4654   4673   ** <li>   SQLITE_MUTEX_W32
  4655   4674   ** <li>   SQLITE_MUTEX_NOOP
  4656         -** </ul>
         4675  +** </ul>)^
  4657   4676   **
  4658         -** The SQLITE_MUTEX_NOOP implementation is a set of routines
         4677  +** ^The SQLITE_MUTEX_NOOP implementation is a set of routines
  4659   4678   ** that does no real locking and is appropriate for use in
  4660         -** a single-threaded application.  The SQLITE_MUTEX_OS2,
         4679  +** a single-threaded application.  ^The SQLITE_MUTEX_OS2,
  4661   4680   ** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations
  4662   4681   ** are appropriate for use on OS/2, Unix, and Windows.
  4663   4682   **
  4664         -** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
         4683  +** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
  4665   4684   ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
  4666   4685   ** implementation is included with the library. In this case the
  4667   4686   ** application must supply a custom mutex implementation using the
  4668   4687   ** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
  4669   4688   ** before calling sqlite3_initialize() or any other public sqlite3_
  4670         -** function that calls sqlite3_initialize().
         4689  +** function that calls sqlite3_initialize().)^
  4671   4690   **
  4672         -** {H17011} The sqlite3_mutex_alloc() routine allocates a new
  4673         -** mutex and returns a pointer to it. {H17012} If it returns NULL
  4674         -** that means that a mutex could not be allocated. {H17013} SQLite
  4675         -** will unwind its stack and return an error. {H17014} The argument
         4691  +** ^The sqlite3_mutex_alloc() routine allocates a new
         4692  +** mutex and returns a pointer to it. ^If it returns NULL
         4693  +** that means that a mutex could not be allocated.  ^SQLite
         4694  +** will unwind its stack and return an error.  ^(The argument
  4676   4695   ** to sqlite3_mutex_alloc() is one of these integer constants:
  4677   4696   **
  4678   4697   ** <ul>
  4679   4698   ** <li>  SQLITE_MUTEX_FAST
  4680   4699   ** <li>  SQLITE_MUTEX_RECURSIVE
  4681   4700   ** <li>  SQLITE_MUTEX_STATIC_MASTER
  4682   4701   ** <li>  SQLITE_MUTEX_STATIC_MEM
  4683   4702   ** <li>  SQLITE_MUTEX_STATIC_MEM2
  4684   4703   ** <li>  SQLITE_MUTEX_STATIC_PRNG
  4685   4704   ** <li>  SQLITE_MUTEX_STATIC_LRU
  4686   4705   ** <li>  SQLITE_MUTEX_STATIC_LRU2
  4687         -** </ul>
         4706  +** </ul>)^
  4688   4707   **
  4689         -** {H17015} The first two constants cause sqlite3_mutex_alloc() to create
  4690         -** a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
  4691         -** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END}
         4708  +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
         4709  +** cause sqlite3_mutex_alloc() to create
         4710  +** a new mutex.  ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
         4711  +** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
  4692   4712   ** The mutex implementation does not need to make a distinction
  4693   4713   ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
  4694         -** not want to.  {H17016} But SQLite will only request a recursive mutex in
  4695         -** cases where it really needs one.  {END} If a faster non-recursive mutex
         4714  +** not want to.  ^SQLite will only request a recursive mutex in
         4715  +** cases where it really needs one.  ^If a faster non-recursive mutex
  4696   4716   ** implementation is available on the host platform, the mutex subsystem
  4697   4717   ** might return such a mutex in response to SQLITE_MUTEX_FAST.
  4698   4718   **
  4699         -** {H17017} The other allowed parameters to sqlite3_mutex_alloc() each return
  4700         -** a pointer to a static preexisting mutex. {END}  Four static mutexes are
         4719  +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
         4720  +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
         4721  +** a pointer to a static preexisting mutex.  ^Six static mutexes are
  4701   4722   ** used by the current version of SQLite.  Future versions of SQLite
  4702   4723   ** may add additional static mutexes.  Static mutexes are for internal
  4703   4724   ** use by SQLite only.  Applications that use SQLite mutexes should
  4704   4725   ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
  4705   4726   ** SQLITE_MUTEX_RECURSIVE.
  4706   4727   **
  4707         -** {H17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
         4728  +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
  4708   4729   ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
  4709         -** returns a different mutex on every call.  {H17034} But for the static
         4730  +** returns a different mutex on every call.  ^But for the static
  4710   4731   ** mutex types, the same mutex is returned on every call that has
  4711   4732   ** the same type number.
  4712   4733   **
  4713         -** {H17019} The sqlite3_mutex_free() routine deallocates a previously
  4714         -** allocated dynamic mutex. {H17020} SQLite is careful to deallocate every
  4715         -** dynamic mutex that it allocates. {A17021} The dynamic mutexes must not be in
  4716         -** use when they are deallocated. {A17022} Attempting to deallocate a static
  4717         -** mutex results in undefined behavior. {H17023} SQLite never deallocates
  4718         -** a static mutex. {END}
         4734  +** ^The sqlite3_mutex_free() routine deallocates a previously
         4735  +** allocated dynamic mutex.  ^SQLite is careful to deallocate every
         4736  +** dynamic mutex that it allocates.  The dynamic mutexes must not be in
         4737  +** use when they are deallocated.  Attempting to deallocate a static
         4738  +** mutex results in undefined behavior.  ^SQLite never deallocates
         4739  +** a static mutex.
  4719   4740   **
  4720         -** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
  4721         -** to enter a mutex. {H17024} If another thread is already within the mutex,
         4741  +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
         4742  +** to enter a mutex.  ^If another thread is already within the mutex,
  4722   4743   ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
  4723         -** SQLITE_BUSY. {H17025}  The sqlite3_mutex_try() interface returns [SQLITE_OK]
  4724         -** upon successful entry.  {H17026} Mutexes created using
         4744  +** SQLITE_BUSY.  ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
         4745  +** upon successful entry.  ^(Mutexes created using
  4725   4746   ** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
  4726         -** {H17027} In such cases the,
         4747  +** In such cases the,
  4727   4748   ** mutex must be exited an equal number of times before another thread
  4728         -** can enter.  {A17028} If the same thread tries to enter any other
         4749  +** can enter.)^  ^(If the same thread tries to enter any other
  4729   4750   ** kind of mutex more than once, the behavior is undefined.
  4730         -** {H17029} SQLite will never exhibit
  4731         -** such behavior in its own use of mutexes.
         4751  +** SQLite will never exhibit
         4752  +** such behavior in its own use of mutexes.)^
  4732   4753   **
  4733         -** Some systems (for example, Windows 95) do not support the operation
         4754  +** ^(Some systems (for example, Windows 95) do not support the operation
  4734   4755   ** implemented by sqlite3_mutex_try().  On those systems, sqlite3_mutex_try()
  4735         -** will always return SQLITE_BUSY.  {H17030} The SQLite core only ever uses
  4736         -** sqlite3_mutex_try() as an optimization so this is acceptable behavior.
         4756  +** will always return SQLITE_BUSY.  The SQLite core only ever uses
         4757  +** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^
  4737   4758   **
  4738         -** {H17031} The sqlite3_mutex_leave() routine exits a mutex that was
  4739         -** previously entered by the same thread.  {A17032} The behavior
         4759  +** ^The sqlite3_mutex_leave() routine exits a mutex that was
         4760  +** previously entered by the same thread.   ^(The behavior
  4740   4761   ** is undefined if the mutex is not currently entered by the
  4741         -** calling thread or is not currently allocated.  {H17033} SQLite will
  4742         -** never do either. {END}
         4762  +** calling thread or is not currently allocated.  SQLite will
         4763  +** never do either.)^
  4743   4764   **
  4744         -** If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
         4765  +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
  4745   4766   ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
  4746   4767   ** behave as no-ops.
  4747   4768   **
  4748   4769   ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
  4749   4770   */
  4750         -sqlite3_mutex *sqlite3_mutex_alloc(int);
  4751         -void sqlite3_mutex_free(sqlite3_mutex*);
  4752         -void sqlite3_mutex_enter(sqlite3_mutex*);
  4753         -int sqlite3_mutex_try(sqlite3_mutex*);
  4754         -void sqlite3_mutex_leave(sqlite3_mutex*);
         4771  +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
         4772  +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
         4773  +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
         4774  +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
         4775  +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
  4755   4776   
  4756   4777   /*
  4757         -** CAPI3REF: Mutex Methods Object {H17120} <S20130>
         4778  +** CAPI3REF: Mutex Methods Object
  4758   4779   ** EXPERIMENTAL
  4759   4780   **
  4760   4781   ** An instance of this structure defines the low-level routines
  4761   4782   ** used to allocate and use mutexes.
  4762   4783   **
  4763   4784   ** Usually, the default mutex implementations provided by SQLite are
  4764   4785   ** sufficient, however the user has the option of substituting a custom
................................................................................
  4766   4787   ** does not provide a suitable implementation. In this case, the user
  4767   4788   ** creates and populates an instance of this structure to pass
  4768   4789   ** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
  4769   4790   ** Additionally, an instance of this structure can be used as an
  4770   4791   ** output variable when querying the system for the current mutex
  4771   4792   ** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
  4772   4793   **
  4773         -** The xMutexInit method defined by this structure is invoked as
         4794  +** ^The xMutexInit method defined by this structure is invoked as
  4774   4795   ** part of system initialization by the sqlite3_initialize() function.
  4775         -** {H17001} The xMutexInit routine shall be called by SQLite once for each
         4796  +** ^The xMutexInit routine is calle by SQLite exactly once for each
  4776   4797   ** effective call to [sqlite3_initialize()].
  4777   4798   **
  4778         -** The xMutexEnd method defined by this structure is invoked as
         4799  +** ^The xMutexEnd method defined by this structure is invoked as
  4779   4800   ** part of system shutdown by the sqlite3_shutdown() function. The
  4780   4801   ** implementation of this method is expected to release all outstanding
  4781   4802   ** resources obtained by the mutex methods implementation, especially
  4782         -** those obtained by the xMutexInit method. {H17003} The xMutexEnd()
  4783         -** interface shall be invoked once for each call to [sqlite3_shutdown()].
         4803  +** those obtained by the xMutexInit method.  ^The xMutexEnd()
         4804  +** interface is invoked exactly once for each call to [sqlite3_shutdown()].
  4784   4805   **
  4785         -** The remaining seven methods defined by this structure (xMutexAlloc,
         4806  +** ^(The remaining seven methods defined by this structure (xMutexAlloc,
  4786   4807   ** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
  4787   4808   ** xMutexNotheld) implement the following interfaces (respectively):
  4788   4809   **
  4789   4810   ** <ul>
  4790   4811   **   <li>  [sqlite3_mutex_alloc()] </li>
  4791   4812   **   <li>  [sqlite3_mutex_free()] </li>
  4792   4813   **   <li>  [sqlite3_mutex_enter()] </li>
  4793   4814   **   <li>  [sqlite3_mutex_try()] </li>
  4794   4815   **   <li>  [sqlite3_mutex_leave()] </li>
  4795   4816   **   <li>  [sqlite3_mutex_held()] </li>
  4796   4817   **   <li>  [sqlite3_mutex_notheld()] </li>
  4797         -** </ul>
         4818  +** </ul>)^
  4798   4819   **
  4799   4820   ** The only difference is that the public sqlite3_XXX functions enumerated
  4800   4821   ** above silently ignore any invocations that pass a NULL pointer instead
  4801   4822   ** of a valid mutex handle. The implementations of the methods defined
  4802   4823   ** by this structure are not required to handle this case, the results
  4803   4824   ** of passing a NULL pointer instead of a valid mutex handle are undefined
  4804   4825   ** (i.e. it is acceptable to provide an implementation that segfaults if
  4805   4826   ** it is passed a NULL pointer).
         4827  +**
         4828  +** The xMutexInit() method must be threadsafe.  ^It must be harmless to
         4829  +** invoke xMutexInit() mutiple times within the same process and without
         4830  +** intervening calls to xMutexEnd().  Second and subsequent calls to
         4831  +** xMutexInit() must be no-ops.
         4832  +**
         4833  +** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
         4834  +** and its associates).  ^Similarly, xMutexAlloc() must not use SQLite memory
         4835  +** allocation for a static mutex.  ^However xMutexAlloc() may use SQLite
         4836  +** memory allocation for a fast or recursive mutex.
         4837  +**
         4838  +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
         4839  +** called, but only if the prior call to xMutexInit returned SQLITE_OK.
         4840  +** If xMutexInit fails in any way, it is expected to clean up after itself
         4841  +** prior to returning.
  4806   4842   */
  4807   4843   typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
  4808   4844   struct sqlite3_mutex_methods {
  4809   4845     int (*xMutexInit)(void);
  4810   4846     int (*xMutexEnd)(void);
  4811   4847     sqlite3_mutex *(*xMutexAlloc)(int);
  4812   4848     void (*xMutexFree)(sqlite3_mutex *);
................................................................................
  4814   4850     int (*xMutexTry)(sqlite3_mutex *);
  4815   4851     void (*xMutexLeave)(sqlite3_mutex *);
  4816   4852     int (*xMutexHeld)(sqlite3_mutex *);
  4817   4853     int (*xMutexNotheld)(sqlite3_mutex *);
  4818   4854   };
  4819   4855   
  4820   4856   /*
  4821         -** CAPI3REF: Mutex Verification Routines {H17080} <S20130> <S30800>
         4857  +** CAPI3REF: Mutex Verification Routines
  4822   4858   **
  4823   4859   ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
  4824         -** are intended for use inside assert() statements. {H17081} The SQLite core
         4860  +** are intended for use inside assert() statements.  ^The SQLite core
  4825   4861   ** never uses these routines except inside an assert() and applications
  4826         -** are advised to follow the lead of the core.  {H17082} The core only
         4862  +** are advised to follow the lead of the core.  ^The SQLite core only
  4827   4863   ** provides implementations for these routines when it is compiled
  4828         -** with the SQLITE_DEBUG flag.  {A17087} External mutex implementations
         4864  +** with the SQLITE_DEBUG flag.  ^External mutex implementations
  4829   4865   ** are only required to provide these routines if SQLITE_DEBUG is
  4830   4866   ** defined and if NDEBUG is not defined.
  4831   4867   **
  4832         -** {H17083} These routines should return true if the mutex in their argument
         4868  +** ^These routines should return true if the mutex in their argument
  4833   4869   ** is held or not held, respectively, by the calling thread.
  4834   4870   **
  4835         -** {X17084} The implementation is not required to provided versions of these
         4871  +** ^The implementation is not required to provided versions of these
  4836   4872   ** routines that actually work. If the implementation does not provide working
  4837   4873   ** versions of these routines, it should at least provide stubs that always
  4838   4874   ** return true so that one does not get spurious assertion failures.
  4839   4875   **
  4840         -** {H17085} If the argument to sqlite3_mutex_held() is a NULL pointer then
  4841         -** the routine should return 1.  {END} This seems counter-intuitive since
         4876  +** ^If the argument to sqlite3_mutex_held() is a NULL pointer then
         4877  +** the routine should return 1.   This seems counter-intuitive since
  4842   4878   ** clearly the mutex cannot be held if it does not exist.  But the
  4843   4879   ** the reason the mutex does not exist is because the build is not
  4844   4880   ** using mutexes.  And we do not want the assert() containing the
  4845   4881   ** call to sqlite3_mutex_held() to fail, so a non-zero return is
  4846         -** the appropriate thing to do.  {H17086} The sqlite3_mutex_notheld()
         4882  +** the appropriate thing to do.  ^The sqlite3_mutex_notheld()
  4847   4883   ** interface should also return 1 when given a NULL pointer.
  4848   4884   */
  4849         -int sqlite3_mutex_held(sqlite3_mutex*);
  4850         -int sqlite3_mutex_notheld(sqlite3_mutex*);
         4885  +#ifndef NDEBUG
         4886  +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
         4887  +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
         4888  +#endif
  4851   4889   
  4852   4890   /*
  4853         -** CAPI3REF: Mutex Types {H17001} <H17000>
         4891  +** CAPI3REF: Mutex Types
  4854   4892   **
  4855   4893   ** The [sqlite3_mutex_alloc()] interface takes a single argument
  4856   4894   ** which is one of these integer constants.
  4857   4895   **
  4858   4896   ** The set of static mutexes may change from one SQLite release to the
  4859   4897   ** next.  Applications that override the built-in mutex logic must be
  4860   4898   ** prepared to accommodate additional static mutexes.
................................................................................
  4866   4904   #define SQLITE_MUTEX_STATIC_MEM2      4  /* NOT USED */
  4867   4905   #define SQLITE_MUTEX_STATIC_OPEN      4  /* sqlite3BtreeOpen() */
  4868   4906   #define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_random() */
  4869   4907   #define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
  4870   4908   #define SQLITE_MUTEX_STATIC_LRU2      7  /* lru page list */
  4871   4909   
  4872   4910   /*
  4873         -** CAPI3REF: Retrieve the mutex for a database connection {H17002} <H17000>
         4911  +** CAPI3REF: Retrieve the mutex for a database connection
  4874   4912   **
  4875         -** This interface returns a pointer the [sqlite3_mutex] object that 
         4913  +** ^This interface returns a pointer the [sqlite3_mutex] object that 
  4876   4914   ** serializes access to the [database connection] given in the argument
  4877   4915   ** when the [threading mode] is Serialized.
  4878         -** If the [threading mode] is Single-thread or Multi-thread then this
         4916  +** ^If the [threading mode] is Single-thread or Multi-thread then this
  4879   4917   ** routine returns a NULL pointer.
  4880   4918   */
  4881         -sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
         4919  +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
  4882   4920   
  4883   4921   /*
  4884         -** CAPI3REF: Low-Level Control Of Database Files {H11300} <S30800>
         4922  +** CAPI3REF: Low-Level Control Of Database Files
  4885   4923   **
  4886         -** {H11301} The [sqlite3_file_control()] interface makes a direct call to the
         4924  +** ^The [sqlite3_file_control()] interface makes a direct call to the
  4887   4925   ** xFileControl method for the [sqlite3_io_methods] object associated
  4888         -** with a particular database identified by the second argument. {H11302} The
  4889         -** name of the database is the name assigned to the database by the
  4890         -** <a href="lang_attach.html">ATTACH</a> SQL command that opened the
  4891         -** database. {H11303} To control the main database file, use the name "main"
  4892         -** or a NULL pointer. {H11304} The third and fourth parameters to this routine
         4926  +** with a particular database identified by the second argument. ^The
         4927  +** name of the database "main" for the main database or "temp" for the
         4928  +** TEMP database, or the name that appears after the AS keyword for
         4929  +** databases that are added using the [ATTACH] SQL command.
         4930  +** ^A NULL pointer can be used in place of "main" to refer to the
         4931  +** main database file.
         4932  +** ^The third and fourth parameters to this routine
  4893   4933   ** are passed directly through to the second and third parameters of
  4894         -** the xFileControl method.  {H11305} The return value of the xFileControl
         4934  +** the xFileControl method.  ^The return value of the xFileControl
  4895   4935   ** method becomes the return value of this routine.
  4896   4936   **
  4897         -** {H11306} If the second parameter (zDbName) does not match the name of any
  4898         -** open database file, then SQLITE_ERROR is returned. {H11307} This error
         4937  +** ^If the second parameter (zDbName) does not match the name of any
         4938  +** open database file, then SQLITE_ERROR is returned.  ^This error
  4899   4939   ** code is not remembered and will not be recalled by [sqlite3_errcode()]
  4900         -** or [sqlite3_errmsg()]. {A11308} The underlying xFileControl method might
  4901         -** also return SQLITE_ERROR.  {A11309} There is no way to distinguish between
         4940  +** or [sqlite3_errmsg()].  The underlying xFileControl method might
         4941  +** also return SQLITE_ERROR.  There is no way to distinguish between
  4902   4942   ** an incorrect zDbName and an SQLITE_ERROR return from the underlying
  4903         -** xFileControl method. {END}
         4943  +** xFileControl method.
  4904   4944   **
  4905   4945   ** See also: [SQLITE_FCNTL_LOCKSTATE]
  4906   4946   */
  4907         -int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
         4947  +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
  4908   4948   
  4909   4949   /*
  4910         -** CAPI3REF: Testing Interface {H11400} <S30800>
         4950  +** CAPI3REF: Testing Interface
  4911   4951   **
  4912         -** The sqlite3_test_control() interface is used to read out internal
         4952  +** ^The sqlite3_test_control() interface is used to read out internal
  4913   4953   ** state of SQLite and to inject faults into SQLite for testing
  4914         -** purposes.  The first parameter is an operation code that determines
         4954  +** purposes.  ^The first parameter is an operation code that determines
  4915   4955   ** the number, meaning, and operation of all subsequent parameters.
  4916   4956   **
  4917   4957   ** This interface is not for use by applications.  It exists solely
  4918   4958   ** for verifying the correct operation of the SQLite library.  Depending
  4919   4959   ** on how the SQLite library is compiled, this interface might not exist.
  4920   4960   **
  4921   4961   ** The details of the operation codes, their meanings, the parameters
  4922   4962   ** they take, and what they do are all subject to change without notice.
  4923   4963   ** Unlike most of the SQLite API, this function is not guaranteed to
  4924   4964   ** operate consistently from one release to the next.
  4925   4965   */
  4926         -int sqlite3_test_control(int op, ...);
         4966  +SQLITE_API int sqlite3_test_control(int op, ...);
  4927   4967   
  4928   4968   /*
  4929         -** CAPI3REF: Testing Interface Operation Codes {H11410} <H11400>
         4969  +** CAPI3REF: Testing Interface Operation Codes
  4930   4970   **
  4931   4971   ** These constants are the valid operation code parameters used
  4932   4972   ** as the first argument to [sqlite3_test_control()].
  4933   4973   **
  4934   4974   ** These parameters and their meanings are subject to change
  4935   4975   ** without notice.  These values are for testing purposes only.
  4936   4976   ** Applications should not use any of these parameters or the
  4937   4977   ** [sqlite3_test_control()] interface.
  4938   4978   */
         4979  +#define SQLITE_TESTCTRL_FIRST                    5
  4939   4980   #define SQLITE_TESTCTRL_PRNG_SAVE                5
  4940   4981   #define SQLITE_TESTCTRL_PRNG_RESTORE             6
  4941   4982   #define SQLITE_TESTCTRL_PRNG_RESET               7
  4942   4983   #define SQLITE_TESTCTRL_BITVEC_TEST              8
  4943   4984   #define SQLITE_TESTCTRL_FAULT_INSTALL            9
  4944   4985   #define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS     10
  4945   4986   #define SQLITE_TESTCTRL_PENDING_BYTE            11
  4946   4987   #define SQLITE_TESTCTRL_ASSERT                  12
  4947   4988   #define SQLITE_TESTCTRL_ALWAYS                  13
         4989  +#define SQLITE_TESTCTRL_RESERVE                 14
         4990  +#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
         4991  +#define SQLITE_TESTCTRL_ISKEYWORD               16
         4992  +#define SQLITE_TESTCTRL_LAST                    16
  4948   4993   
  4949   4994   /*
  4950         -** CAPI3REF: SQLite Runtime Status {H17200} <S60200>
         4995  +** CAPI3REF: SQLite Runtime Status
  4951   4996   ** EXPERIMENTAL
  4952   4997   **
  4953         -** This interface is used to retrieve runtime status information
         4998  +** ^This interface is used to retrieve runtime status information
  4954   4999   ** about the preformance of SQLite, and optionally to reset various
  4955         -** highwater marks.  The first argument is an integer code for
  4956         -** the specific parameter to measure.  Recognized integer codes
  4957         -** are of the form [SQLITE_STATUS_MEMORY_USED | SQLITE_STATUS_...].
  4958         -** The current value of the parameter is returned into *pCurrent.
  4959         -** The highest recorded value is returned in *pHighwater.  If the
         5000  +** highwater marks.  ^The first argument is an integer code for
         5001  +** the specific parameter to measure.  ^(Recognized integer codes
         5002  +** are of the form [SQLITE_STATUS_MEMORY_USED | SQLITE_STATUS_...].)^
         5003  +** ^The current value of the parameter is returned into *pCurrent.
         5004  +** ^The highest recorded value is returned in *pHighwater.  ^If the
  4960   5005   ** resetFlag is true, then the highest record value is reset after
  4961         -** *pHighwater is written. Some parameters do not record the highest
         5006  +** *pHighwater is written.  ^(Some parameters do not record the highest
  4962   5007   ** value.  For those parameters
  4963         -** nothing is written into *pHighwater and the resetFlag is ignored.
  4964         -** Other parameters record only the highwater mark and not the current
  4965         -** value.  For these latter parameters nothing is written into *pCurrent.
         5008  +** nothing is written into *pHighwater and the resetFlag is ignored.)^
         5009  +** ^(Other parameters record only the highwater mark and not the current
         5010  +** value.  For these latter parameters nothing is written into *pCurrent.)^
  4966   5011   **
  4967         -** This routine returns SQLITE_OK on success and a non-zero
  4968         -** [error code] on failure.
         5012  +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
         5013  +** non-zero [error code] on failure.
  4969   5014   **
  4970         -** This routine is threadsafe but is not atomic.  This routine can
         5015  +** This routine is threadsafe but is not atomic.  This routine can be
  4971   5016   ** called while other threads are running the same or different SQLite
  4972   5017   ** interfaces.  However the values returned in *pCurrent and
  4973   5018   ** *pHighwater reflect the status of SQLite at different points in time
  4974   5019   ** and it is possible that another thread might change the parameter
  4975   5020   ** in between the times when *pCurrent and *pHighwater are written.
  4976   5021   **
  4977   5022   ** See also: [sqlite3_db_status()]
  4978   5023   */
  4979         -SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
         5024  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
  4980   5025   
  4981   5026   
  4982   5027   /*
  4983         -** CAPI3REF: Status Parameters {H17250} <H17200>
         5028  +** CAPI3REF: Status Parameters
  4984   5029   ** EXPERIMENTAL
  4985   5030   **
  4986   5031   ** These integer constants designate various run-time status parameters
  4987   5032   ** that can be returned by [sqlite3_status()].
  4988   5033   **
  4989   5034   ** <dl>
  4990         -** <dt>SQLITE_STATUS_MEMORY_USED</dt>
         5035  +** ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
  4991   5036   ** <dd>This parameter is the current amount of memory checked out
  4992   5037   ** using [sqlite3_malloc()], either directly or indirectly.  The
  4993   5038   ** figure includes calls made to [sqlite3_malloc()] by the application
  4994   5039   ** and internal memory usage by the SQLite library.  Scratch memory
  4995   5040   ** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
  4996   5041   ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
  4997   5042   ** this parameter.  The amount returned is the sum of the allocation
  4998         -** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>
         5043  +** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
  4999   5044   **
  5000         -** <dt>SQLITE_STATUS_MALLOC_SIZE</dt>
         5045  +** ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
  5001   5046   ** <dd>This parameter records the largest memory allocation request
  5002   5047   ** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their
  5003   5048   ** internal equivalents).  Only the value returned in the
  5004   5049   ** *pHighwater parameter to [sqlite3_status()] is of interest.  
  5005         -** The value written into the *pCurrent parameter is undefined.</dd>
         5050  +** The value written into the *pCurrent parameter is undefined.</dd>)^
  5006   5051   **
  5007         -** <dt>SQLITE_STATUS_PAGECACHE_USED</dt>
         5052  +** ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
  5008   5053   ** <dd>This parameter returns the number of pages used out of the
  5009   5054   ** [pagecache memory allocator] that was configured using 
  5010   5055   ** [SQLITE_CONFIG_PAGECACHE].  The
  5011         -** value returned is in pages, not in bytes.</dd>
         5056  +** value returned is in pages, not in bytes.</dd>)^
  5012   5057   **
  5013         -** <dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
         5058  +** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
  5014   5059   ** <dd>This parameter returns the number of bytes of page cache
  5015   5060   ** allocation which could not be statisfied by the [SQLITE_CONFIG_PAGECACHE]
  5016   5061   ** buffer and where forced to overflow to [sqlite3_malloc()].  The
  5017   5062   ** returned value includes allocations that overflowed because they
  5018   5063   ** where too large (they were larger than the "sz" parameter to
  5019   5064   ** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because
  5020         -** no space was left in the page cache.</dd>
         5065  +** no space was left in the page cache.</dd>)^
  5021   5066   **
  5022         -** <dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
         5067  +** ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
  5023   5068   ** <dd>This parameter records the largest memory allocation request
  5024   5069   ** handed to [pagecache memory allocator].  Only the value returned in the
  5025   5070   ** *pHighwater parameter to [sqlite3_status()] is of interest.  
  5026         -** The value written into the *pCurrent parameter is undefined.</dd>
         5071  +** The value written into the *pCurrent parameter is undefined.</dd>)^
  5027   5072   **
  5028         -** <dt>SQLITE_STATUS_SCRATCH_USED</dt>
         5073  +** ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
  5029   5074   ** <dd>This parameter returns the number of allocations used out of the
  5030   5075   ** [scratch memory allocator] configured using
  5031   5076   ** [SQLITE_CONFIG_SCRATCH].  The value returned is in allocations, not
  5032   5077   ** in bytes.  Since a single thread may only have one scratch allocation
  5033   5078   ** outstanding at time, this parameter also reports the number of threads
  5034         -** using scratch memory at the same time.</dd>
         5079  +** using scratch memory at the same time.</dd>)^
  5035   5080   **
  5036         -** <dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
         5081  +** ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
  5037   5082   ** <dd>This parameter returns the number of bytes of scratch memory
  5038   5083   ** allocation which could not be statisfied by the [SQLITE_CONFIG_SCRATCH]
  5039   5084   ** buffer and where forced to overflow to [sqlite3_malloc()].  The values
  5040   5085   ** returned include overflows because the requested allocation was too
  5041   5086   ** larger (that is, because the requested allocation was larger than the
  5042   5087   ** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
  5043   5088   ** slots were available.
  5044         -** </dd>
         5089  +** </dd>)^
  5045   5090   **
  5046         -** <dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
         5091  +** ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
  5047   5092   ** <dd>This parameter records the largest memory allocation request
  5048   5093   ** handed to [scratch memory allocator].  Only the value returned in the
  5049   5094   ** *pHighwater parameter to [sqlite3_status()] is of interest.  
  5050         -** The value written into the *pCurrent parameter is undefined.</dd>
         5095  +** The value written into the *pCurrent parameter is undefined.</dd>)^
  5051   5096   **
  5052         -** <dt>SQLITE_STATUS_PARSER_STACK</dt>
         5097  +** ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
  5053   5098   ** <dd>This parameter records the deepest parser stack.  It is only
  5054         -** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>
         5099  +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
  5055   5100   ** </dl>
  5056   5101   **
  5057   5102   ** New status parameters may be added from time to time.
  5058   5103   */
  5059   5104   #define SQLITE_STATUS_MEMORY_USED          0
  5060   5105   #define SQLITE_STATUS_PAGECACHE_USED       1
  5061   5106   #define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
................................................................................
  5063   5108   #define SQLITE_STATUS_SCRATCH_OVERFLOW     4
  5064   5109   #define SQLITE_STATUS_MALLOC_SIZE          5
  5065   5110   #define SQLITE_STATUS_PARSER_STACK         6
  5066   5111   #define SQLITE_STATUS_PAGECACHE_SIZE       7
  5067   5112   #define SQLITE_STATUS_SCRATCH_SIZE         8
  5068   5113   
  5069   5114   /*
  5070         -** CAPI3REF: Database Connection Status {H17500} <S60200>
         5115  +** CAPI3REF: Database Connection Status
  5071   5116   ** EXPERIMENTAL
  5072   5117   **
  5073         -** This interface is used to retrieve runtime status information 
  5074         -** about a single [database connection].  The first argument is the
  5075         -** database connection object to be interrogated.  The second argument
  5076         -** is the parameter to interrogate.  Currently, the only allowed value
         5118  +** ^This interface is used to retrieve runtime status information 
         5119  +** about a single [database connection].  ^The first argument is the
         5120  +** database connection object to be interrogated.  ^The second argument
         5121  +** is the parameter to interrogate.  ^Currently, the only allowed value
  5077   5122   ** for the second parameter is [SQLITE_DBSTATUS_LOOKASIDE_USED].
  5078   5123   ** Additional options will likely appear in future releases of SQLite.
  5079   5124   **
  5080         -** The current value of the requested parameter is written into *pCur
  5081         -** and the highest instantaneous value is written into *pHiwtr.  If
         5125  +** ^The current value of the requested parameter is written into *pCur
         5126  +** and the highest instantaneous value is written into *pHiwtr.  ^If
  5082   5127   ** the resetFlg is true, then the highest instantaneous value is
  5083   5128   ** reset back down to the current value.
  5084   5129   **
  5085   5130   ** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
  5086   5131   */
  5087         -SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
         5132  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
  5088   5133   
  5089   5134   /*
  5090         -** CAPI3REF: Status Parameters for database connections {H17520} <H17500>
         5135  +** CAPI3REF: Status Parameters for database connections
  5091   5136   ** EXPERIMENTAL
  5092   5137   **
  5093         -** Status verbs for [sqlite3_db_status()].
         5138  +** These constants are the available integer "verbs" that can be passed as
         5139  +** the second argument to the [sqlite3_db_status()] interface.
         5140  +**
         5141  +** New verbs may be added in future releases of SQLite. Existing verbs
         5142  +** might be discontinued. Applications should check the return code from
         5143  +** [sqlite3_db_status()] to make sure that the call worked.
         5144  +** The [sqlite3_db_status()] interface will return a non-zero error code
         5145  +** if a discontinued or unsupported verb is invoked.
  5094   5146   **
  5095   5147   ** <dl>
  5096         -** <dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
         5148  +** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
  5097   5149   ** <dd>This parameter returns the number of lookaside memory slots currently
  5098         -** checked out.</dd>
         5150  +** checked out.</dd>)^
  5099   5151   ** </dl>
  5100   5152   */
  5101   5153   #define SQLITE_DBSTATUS_LOOKASIDE_USED     0
  5102   5154   
  5103   5155   
  5104   5156   /*
  5105         -** CAPI3REF: Prepared Statement Status {H17550} <S60200>
         5157  +** CAPI3REF: Prepared Statement Status
  5106   5158   ** EXPERIMENTAL
  5107   5159   **
  5108         -** Each prepared statement maintains various
         5160  +** ^(Each prepared statement maintains various
  5109   5161   ** [SQLITE_STMTSTATUS_SORT | counters] that measure the number
  5110         -** of times it has performed specific operations.  These counters can
         5162  +** of times it has performed specific operations.)^  These counters can
  5111   5163   ** be used to monitor the performance characteristics of the prepared
  5112   5164   ** statements.  For example, if the number of table steps greatly exceeds
  5113   5165   ** the number of table searches or result rows, that would tend to indicate
  5114   5166   ** that the prepared statement is using a full table scan rather than
  5115   5167   ** an index.  
  5116   5168   **
  5117         -** This interface is used to retrieve and reset counter values from
         5169  +** ^(This interface is used to retrieve and reset counter values from
  5118   5170   ** a [prepared statement].  The first argument is the prepared statement
  5119   5171   ** object to be interrogated.  The second argument
  5120   5172   ** is an integer code for a specific [SQLITE_STMTSTATUS_SORT | counter]
  5121         -** to be interrogated. 
  5122         -** The current value of the requested counter is returned.
  5123         -** If the resetFlg is true, then the counter is reset to zero after this
         5173  +** to be interrogated.)^
         5174  +** ^The current value of the requested counter is returned.
         5175  +** ^If the resetFlg is true, then the counter is reset to zero after this
  5124   5176   ** interface call returns.
  5125   5177   **
  5126   5178   ** See also: [sqlite3_status()] and [sqlite3_db_status()].
  5127   5179   */
  5128         -SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
         5180  +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
  5129   5181   
  5130   5182   /*
  5131         -** CAPI3REF: Status Parameters for prepared statements {H17570} <H17550>
         5183  +** CAPI3REF: Status Parameters for prepared statements
  5132   5184   ** EXPERIMENTAL
  5133   5185   **
  5134   5186   ** These preprocessor macros define integer codes that name counter
  5135   5187   ** values associated with the [sqlite3_stmt_status()] interface.
  5136   5188   ** The meanings of the various counters are as follows:
  5137   5189   **
  5138   5190   ** <dl>
  5139   5191   ** <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
  5140         -** <dd>This is the number of times that SQLite has stepped forward in
         5192  +** <dd>^This is the number of times that SQLite has stepped forward in
  5141   5193   ** a table as part of a full table scan.  Large numbers for this counter
  5142   5194   ** may indicate opportunities for performance improvement through 
  5143   5195   ** careful use of indices.</dd>
  5144   5196   **
  5145   5197   ** <dt>SQLITE_STMTSTATUS_SORT</dt>
  5146         -** <dd>This is the number of sort operations that have occurred.
         5198  +** <dd>^This is the number of sort operations that have occurred.
  5147   5199   ** A non-zero value in this counter may indicate an opportunity to
  5148   5200   ** improvement performance through careful use of indices.</dd>
  5149   5201   **
  5150   5202   ** </dl>
  5151   5203   */
  5152   5204   #define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
  5153   5205   #define SQLITE_STMTSTATUS_SORT              2
................................................................................
  5164   5216   **
  5165   5217   ** See [sqlite3_pcache_methods] for additional information.
  5166   5218   */
  5167   5219   typedef struct sqlite3_pcache sqlite3_pcache;
  5168   5220   
  5169   5221   /*
  5170   5222   ** CAPI3REF: Application Defined Page Cache.
         5223  +** KEYWORDS: {page cache}
  5171   5224   ** EXPERIMENTAL
  5172   5225   **
  5173         -** The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can
         5226  +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE], ...) interface can
  5174   5227   ** register an alternative page cache implementation by passing in an 
  5175         -** instance of the sqlite3_pcache_methods structure. The majority of the 
  5176         -** heap memory used by sqlite is used by the page cache to cache data read 
         5228  +** instance of the sqlite3_pcache_methods structure.)^ The majority of the 
         5229  +** heap memory used by SQLite is used by the page cache to cache data read 
  5177   5230   ** from, or ready to be written to, the database file. By implementing a 
  5178   5231   ** custom page cache using this API, an application can control more 
  5179         -** precisely the amount of memory consumed by sqlite, the way in which 
  5180         -** said memory is allocated and released, and the policies used to 
         5232  +** precisely the amount of memory consumed by SQLite, the way in which 
         5233  +** that memory is allocated and released, and the policies used to 
  5181   5234   ** determine exactly which parts of a database file are cached and for 
  5182   5235   ** how long.
  5183   5236   **
  5184         -** The contents of the structure are copied to an internal buffer by sqlite
  5185         -** within the call to [sqlite3_config].
         5237  +** ^(The contents of the sqlite3_pcache_methods structure are copied to an
         5238  +** internal buffer by SQLite within the call to [sqlite3_config].  Hence
         5239  +** the application may discard the parameter after the call to
         5240  +** [sqlite3_config()] returns.)^
  5186   5241   **
  5187         -** The xInit() method is called once for each call to [sqlite3_initialize()]
  5188         -** (usually only once during the lifetime of the process). It is passed
  5189         -** a copy of the sqlite3_pcache_methods.pArg value. It can be used to set
  5190         -** up global structures and mutexes required by the custom page cache 
  5191         -** implementation. The xShutdown() method is called from within 
  5192         -** [sqlite3_shutdown()], if the application invokes this API. It can be used
  5193         -** to clean up any outstanding resources before process shutdown, if required.
         5242  +** ^The xInit() method is called once for each call to [sqlite3_initialize()]
         5243  +** (usually only once during the lifetime of the process). ^(The xInit()
         5244  +** method is passed a copy of the sqlite3_pcache_methods.pArg value.)^
         5245  +** ^The xInit() method can set up up global structures and/or any mutexes
         5246  +** required by the custom page cache implementation. 
  5194   5247   **
  5195         -** The xCreate() method is used to construct a new cache instance. The
         5248  +** ^The xShutdown() method is called from within [sqlite3_shutdown()], 
         5249  +** if the application invokes this API. It can be used to clean up 
         5250  +** any outstanding resources before process shutdown, if required.
         5251  +**
         5252  +** ^SQLite holds a [SQLITE_MUTEX_RECURSIVE] mutex when it invokes
         5253  +** the xInit method, so the xInit method need not be threadsafe.  ^The
         5254  +** xShutdown method is only called from [sqlite3_shutdown()] so it does
         5255  +** not need to be threadsafe either.  All other methods must be threadsafe
         5256  +** in multithreaded applications.
         5257  +**
         5258  +** ^SQLite will never invoke xInit() more than once without an intervening
         5259  +** call to xShutdown().
         5260  +**
         5261  +** ^The xCreate() method is used to construct a new cache instance.  SQLite
         5262  +** will typically create one cache instance for each open database file,
         5263  +** though this is not guaranteed. ^The
  5196   5264   ** first parameter, szPage, is the size in bytes of the pages that must
  5197         -** be allocated by the cache. szPage will not be a power of two. The
  5198         -** second argument, bPurgeable, is true if the cache being created will
  5199         -** be used to cache database pages read from a file stored on disk, or
  5200         -** false if it is used for an in-memory database. The cache implementation
  5201         -** does not have to do anything special based on the value of bPurgeable,
  5202         -** it is purely advisory. 
         5265  +** be allocated by the cache.  ^szPage will not be a power of two.  ^szPage
         5266  +** will the page size of the database file that is to be cached plus an
         5267  +** increment (here called "R") of about 100 or 200.  ^SQLite will use the
         5268  +** extra R bytes on each page to store metadata about the underlying
         5269  +** database page on disk.  The value of R depends
         5270  +** on the SQLite version, the target platform, and how SQLite was compiled.
         5271  +** ^R is constant for a particular build of SQLite.  ^The second argument to
         5272  +** xCreate(), bPurgeable, is true if the cache being created will
         5273  +** be used to cache database pages of a file stored on disk, or
         5274  +** false if it is used for an in-memory database. ^The cache implementation
         5275  +** does not have to do anything special based with the value of bPurgeable;
         5276  +** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
         5277  +** never invoke xUnpin() except to deliberately delete a page.
         5278  +** ^In other words, a cache created with bPurgeable set to false will
         5279  +** never contain any unpinned pages.
  5203   5280   **
  5204         -** The xCachesize() method may be called at any time by SQLite to set the
         5281  +** ^(The xCachesize() method may be called at any time by SQLite to set the
  5205   5282   ** suggested maximum cache-size (number of pages stored by) the cache
  5206   5283   ** instance passed as the first argument. This is the value configured using
  5207         -** the SQLite "[PRAGMA cache_size]" command. As with the bPurgeable parameter,
  5208         -** the implementation is not required to do anything special with this
  5209         -** value, it is advisory only.
         5284  +** the SQLite "[PRAGMA cache_size]" command.)^  ^As with the bPurgeable
         5285  +** parameter, the implementation is not required to do anything with this
         5286  +** value; it is advisory only.
  5210   5287   **
  5211         -** The xPagecount() method should return the number of pages currently
  5212         -** stored in the cache supplied as an argument.
         5288  +** ^The xPagecount() method should return the number of pages currently
         5289  +** stored in the cache.
  5213   5290   ** 
  5214         -** The xFetch() method is used to fetch a page and return a pointer to it. 
  5215         -** A 'page', in this context, is a buffer of szPage bytes aligned at an
  5216         -** 8-byte boundary. The page to be fetched is determined by the key. The
         5291  +** ^The xFetch() method is used to fetch a page and return a pointer to it. 
         5292  +** ^A 'page', in this context, is a buffer of szPage bytes aligned at an
         5293  +** 8-byte boundary. ^The page to be fetched is determined by the key. ^The
  5217   5294   ** mimimum key value is 1. After it has been retrieved using xFetch, the page 
  5218         -** is considered to be pinned.
         5295  +** is considered to be "pinned".
  5219   5296   **
  5220         -** If the requested page is already in the page cache, then a pointer to
  5221         -** the cached buffer should be returned with its contents intact. If the
  5222         -** page is not already in the cache, then the expected behaviour of the
  5223         -** cache is determined by the value of the createFlag parameter passed
  5224         -** to xFetch, according to the following table:
         5297  +** ^If the requested page is already in the page cache, then the page cache
         5298  +** implementation must return a pointer to the page buffer with its content
         5299  +** intact.  ^(If the requested page is not already in the cache, then the
         5300  +** behavior of the cache implementation is determined by the value of the
         5301  +** createFlag parameter passed to xFetch, according to the following table:
  5225   5302   **
  5226   5303   ** <table border=1 width=85% align=center>
  5227         -**   <tr><th>createFlag<th>Expected Behaviour
  5228         -**   <tr><td>0<td>NULL should be returned. No new cache entry is created.
  5229         -**   <tr><td>1<td>If createFlag is set to 1, this indicates that 
  5230         -**                SQLite is holding pinned pages that can be unpinned
  5231         -**                by writing their contents to the database file (a
  5232         -**                relatively expensive operation). In this situation the
  5233         -**                cache implementation has two choices: it can return NULL,
  5234         -**                in which case SQLite will attempt to unpin one or more 
  5235         -**                pages before re-requesting the same page, or it can
  5236         -**                allocate a new page and return a pointer to it. If a new
  5237         -**                page is allocated, then the first sizeof(void*) bytes of
  5238         -**                it (at least) must be zeroed before it is returned.
  5239         -**   <tr><td>2<td>If createFlag is set to 2, then SQLite is not holding any
  5240         -**                pinned pages associated with the specific cache passed
  5241         -**                as the first argument to xFetch() that can be unpinned. The
  5242         -**                cache implementation should attempt to allocate a new
  5243         -**                cache entry and return a pointer to it. Again, the first
  5244         -**                sizeof(void*) bytes of the page should be zeroed before 
  5245         -**                it is returned. If the xFetch() method returns NULL when 
  5246         -**                createFlag==2, SQLite assumes that a memory allocation 
  5247         -**                failed and returns SQLITE_NOMEM to the user.
  5248         -** </table>
  5249         -**
  5250         -** xUnpin() is called by SQLite with a pointer to a currently pinned page
  5251         -** as its second argument. If the third parameter, discard, is non-zero,
         5304  +** <tr><th> createFlag <th> Behaviour when page is not already in cache
         5305  +** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
         5306  +** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
         5307  +**                 Otherwise return NULL.
         5308  +** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
         5309  +**                 NULL if allocating a new page is effectively impossible.
         5310  +** </table>)^
         5311  +**
         5312  +** SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  If
         5313  +** a call to xFetch() with createFlag==1 returns NULL, then SQLite will
         5314  +** attempt to unpin one or more cache pages by spilling the content of
         5315  +** pinned pages to disk and synching the operating system disk cache. After
         5316  +** attempting to unpin pages, the xFetch() method will be invoked again with
         5317  +** a createFlag of 2.
         5318  +**
         5319  +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
         5320  +** as its second argument. ^(If the third parameter, discard, is non-zero,
  5252   5321   ** then the page should be evicted from the cache. In this case SQLite 
  5253   5322   ** assumes that the next time the page is retrieved from the cache using
  5254         -** the xFetch() method, it will be zeroed. If the discard parameter is
  5255         -** zero, then the page is considered to be unpinned. The cache implementation
  5256         -** may choose to reclaim (free or recycle) unpinned pages at any time.
  5257         -** SQLite assumes that next time the page is retrieved from the cache
  5258         -** it will either be zeroed, or contain the same data that it did when it
  5259         -** was unpinned.
         5323  +** the xFetch() method, it will be zeroed.)^ ^If the discard parameter is
         5324  +** zero, then the page is considered to be unpinned. ^The cache implementation
         5325  +** may choose to evict unpinned pages at any time.
  5260   5326   **
  5261         -** The cache is not required to perform any reference counting. A single 
         5327  +** ^(The cache is not required to perform any reference counting. A single 
  5262   5328   ** call to xUnpin() unpins the page regardless of the number of prior calls 
  5263         -** to xFetch().
         5329  +** to xFetch().)^
  5264   5330   **
  5265         -** The xRekey() method is used to change the key value associated with the
  5266         -** page passed as the second argument from oldKey to newKey. If the cache
         5331  +** ^The xRekey() method is used to change the key value associated with the
         5332  +** page passed as the second argument from oldKey to newKey. ^If the cache
  5267   5333   ** previously contains an entry associated with newKey, it should be
  5268         -** discarded. Any prior cache entry associated with newKey is guaranteed not
         5334  +** discarded. ^Any prior cache entry associated with newKey is guaranteed not
  5269   5335   ** to be pinned.
  5270   5336   **
  5271         -** When SQLite calls the xTruncate() method, the cache must discard all
         5337  +** ^When SQLite calls the xTruncate() method, the cache must discard all
  5272   5338   ** existing cache entries with page numbers (keys) greater than or equal
  5273         -** to the value of the iLimit parameter passed to xTruncate(). If any
         5339  +** to the value of the iLimit parameter passed to xTruncate(). ^If any
  5274   5340   ** of these pages are pinned, they are implicitly unpinned, meaning that
  5275   5341   ** they can be safely discarded.
  5276   5342   **
  5277         -** The xDestroy() method is used to delete a cache allocated by xCreate().
  5278         -** All resources associated with the specified cache should be freed. After
         5343  +** ^The xDestroy() method is used to delete a cache allocated by xCreate().
         5344  +** All resources associated with the specified cache should be freed. ^After
  5279   5345   ** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
  5280   5346   ** handle invalid, and will not use it with any other sqlite3_pcache_methods
  5281   5347   ** functions.
  5282   5348   */
  5283   5349   typedef struct sqlite3_pcache_methods sqlite3_pcache_methods;
  5284   5350   struct sqlite3_pcache_methods {
  5285   5351     void *pArg;
................................................................................
  5296   5362   };
  5297   5363   
  5298   5364   /*
  5299   5365   ** CAPI3REF: Online Backup Object
  5300   5366   ** EXPERIMENTAL
  5301   5367   **
  5302   5368   ** The sqlite3_backup object records state information about an ongoing
  5303         -** online backup operation.  The sqlite3_backup object is created by
         5369  +** online backup operation.  ^The sqlite3_backup object is created by
  5304   5370   ** a call to [sqlite3_backup_init()] and is destroyed by a call to
  5305   5371   ** [sqlite3_backup_finish()].
  5306   5372   **
  5307   5373   ** See Also: [Using the SQLite Online Backup API]
  5308   5374   */
  5309   5375   typedef struct sqlite3_backup sqlite3_backup;
  5310   5376   
  5311   5377   /*
  5312   5378   ** CAPI3REF: Online Backup API.
  5313   5379   ** EXPERIMENTAL
  5314   5380   **
  5315         -** This API is used to overwrite the contents of one database with that
  5316         -** of another. It is useful either for creating backups of databases or
         5381  +** The backup API copies the content of one database into another.
         5382  +** It is useful either for creating backups of databases or
  5317   5383   ** for copying in-memory databases to or from persistent files. 
  5318   5384   **
  5319   5385   ** See Also: [Using the SQLite Online Backup API]
  5320   5386   **
  5321         -** Exclusive access is required to the destination database for the 
  5322         -** duration of the operation. However the source database is only
  5323         -** read-locked while it is actually being read, it is not locked
  5324         -** continuously for the entire operation. Thus, the backup may be
  5325         -** performed on a live database without preventing other users from
  5326         -** writing to the database for an extended period of time.
         5387  +** ^Exclusive access is required to the destination database for the 
         5388  +** duration of the operation. ^However the source database is only
         5389  +** read-locked while it is actually being read; it is not locked
         5390  +** continuously for the entire backup operation. ^Thus, the backup may be
         5391  +** performed on a live source database without preventing other users from
         5392  +** reading or writing to the source database while the backup is underway.
  5327   5393   ** 
  5328         -** To perform a backup operation: 
         5394  +** ^(To perform a backup operation: 
  5329   5395   **   <ol>
  5330   5396   **     <li><b>sqlite3_backup_init()</b> is called once to initialize the
  5331   5397   **         backup, 
  5332   5398   **     <li><b>sqlite3_backup_step()</b> is called one or more times to transfer 
  5333   5399   **         the data between the two databases, and finally
  5334   5400   **     <li><b>sqlite3_backup_finish()</b> is called to release all resources 
  5335   5401   **         associated with the backup operation. 
  5336         -**   </ol>
         5402  +**   </ol>)^
  5337   5403   ** There should be exactly one call to sqlite3_backup_finish() for each
  5338   5404   ** successful call to sqlite3_backup_init().
  5339   5405   **
  5340   5406   ** <b>sqlite3_backup_init()</b>
  5341   5407   **
  5342         -** The first two arguments passed to [sqlite3_backup_init()] are the database
  5343         -** handle associated with the destination database and the database name 
  5344         -** used to attach the destination database to the handle. The database name
  5345         -** is "main" for the main database, "temp" for the temporary database, or
  5346         -** the name specified as part of the [ATTACH] statement if the destination is
  5347         -** an attached database. The third and fourth arguments passed to 
  5348         -** sqlite3_backup_init() identify the [database connection]
  5349         -** and database name used
  5350         -** to access the source database. The values passed for the source and 
  5351         -** destination [database connection] parameters must not be the same.
         5408  +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the 
         5409  +** [database connection] associated with the destination database 
         5410  +** and the database name, respectively.
         5411  +** ^The database name is "main" for the main database, "temp" for the
         5412  +** temporary database, or the name specified after the AS keyword in
         5413  +** an [ATTACH] statement for an attached database.
         5414  +** ^The S and M arguments passed to 
         5415  +** sqlite3_backup_init(D,N,S,M) identify the [database connection]
         5416  +** and database name of the source database, respectively.
         5417  +** ^The source and destination [database connections] (parameters S and D)
         5418  +** must be different or else sqlite3_backup_init(D,N,S,M) will file with
         5419  +** an error.
  5352   5420   **
  5353         -** If an error occurs within sqlite3_backup_init(), then NULL is returned
  5354         -** and an error code and error message written into the [database connection] 
  5355         -** passed as the first argument. They may be retrieved using the
  5356         -** [sqlite3_errcode()], [sqlite3_errmsg()], and [sqlite3_errmsg16()] functions.
  5357         -** Otherwise, if successful, a pointer to an [sqlite3_backup] object is
  5358         -** returned. This pointer may be used with the sqlite3_backup_step() and
         5421  +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
         5422  +** returned and an error code and error message are store3d in the
         5423  +** destination [database connection] D.
         5424  +** ^The error code and message for the failed call to sqlite3_backup_init()
         5425  +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or
         5426  +** [sqlite3_errmsg16()] functions.
         5427  +** ^A successful call to sqlite3_backup_init() returns a pointer to an
         5428  +** [sqlite3_backup] object.
         5429  +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and
  5359   5430   ** sqlite3_backup_finish() functions to perform the specified backup 
  5360   5431   ** operation.
  5361   5432   **
  5362   5433   ** <b>sqlite3_backup_step()</b>
  5363   5434   **
  5364         -** Function [sqlite3_backup_step()] is used to copy up to nPage pages between 
  5365         -** the source and destination databases, where nPage is the value of the 
  5366         -** second parameter passed to sqlite3_backup_step(). If nPage is a negative
  5367         -** value, all remaining source pages are copied. If the required pages are 
  5368         -** succesfully copied, but there are still more pages to copy before the 
  5369         -** backup is complete, it returns [SQLITE_OK]. If no error occured and there 
  5370         -** are no more pages to copy, then [SQLITE_DONE] is returned. If an error 
  5371         -** occurs, then an SQLite error code is returned. As well as [SQLITE_OK] and
         5435  +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between 
         5436  +** the source and destination databases specified by [sqlite3_backup] object B.
         5437  +** ^If N is negative, all remaining source pages are copied. 
         5438  +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there
         5439  +** are still more pages to be copied, then the function resturns [SQLITE_OK].
         5440  +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
         5441  +** from source to destination, then it returns [SQLITE_DONE].
         5442  +** ^If an error occurs while running sqlite3_backup_step(B,N),
         5443  +** then an [error code] is returned. ^As well as [SQLITE_OK] and
  5372   5444   ** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY],
  5373   5445   ** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an
  5374   5446   ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code.
  5375   5447   **
  5376         -** As well as the case where the destination database file was opened for
  5377         -** read-only access, sqlite3_backup_step() may return [SQLITE_READONLY] if
         5448  +** ^The sqlite3_backup_step() might return [SQLITE_READONLY] if the destination
         5449  +** database was opened read-only or if
  5378   5450   ** the destination is an in-memory database with a different page size
  5379   5451   ** from the source database.
  5380   5452   **
  5381         -** If sqlite3_backup_step() cannot obtain a required file-system lock, then
         5453  +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
  5382   5454   ** the [sqlite3_busy_handler | busy-handler function]
  5383         -** is invoked (if one is specified). If the 
         5455  +** is invoked (if one is specified). ^If the 
  5384   5456   ** busy-handler returns non-zero before the lock is available, then 
  5385         -** [SQLITE_BUSY] is returned to the caller. In this case the call to
  5386         -** sqlite3_backup_step() can be retried later. If the source
         5457  +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to
         5458  +** sqlite3_backup_step() can be retried later. ^If the source
  5387   5459   ** [database connection]
  5388   5460   ** is being used to write to the source database when sqlite3_backup_step()
  5389         -** is called, then [SQLITE_LOCKED] is returned immediately. Again, in this
  5390         -** case the call to sqlite3_backup_step() can be retried later on. If
         5461  +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
         5462  +** case the call to sqlite3_backup_step() can be retried later on. ^(If
  5391   5463   ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or
  5392   5464   ** [SQLITE_READONLY] is returned, then 
  5393   5465   ** there is no point in retrying the call to sqlite3_backup_step(). These 
  5394         -** errors are considered fatal. At this point the application must accept 
         5466  +** errors are considered fatal.)^  The application must accept 
  5395   5467   ** that the backup operation has failed and pass the backup operation handle 
  5396   5468   ** to the sqlite3_backup_finish() to release associated resources.
  5397   5469   **
  5398         -** Following the first call to sqlite3_backup_step(), an exclusive lock is
  5399         -** obtained on the destination file. It is not released until either 
         5470  +** ^The first call to sqlite3_backup_step() obtains an exclusive lock
         5471  +** on the destination file. ^The exclusive lock is not released until either 
  5400   5472   ** sqlite3_backup_finish() is called or the backup operation is complete 
  5401         -** and sqlite3_backup_step() returns [SQLITE_DONE]. Additionally, each time 
  5402         -** a call to sqlite3_backup_step() is made a [shared lock] is obtained on
  5403         -** the source database file. This lock is released before the
  5404         -** sqlite3_backup_step() call returns. Because the source database is not
  5405         -** locked between calls to sqlite3_backup_step(), it may be modified mid-way
  5406         -** through the backup procedure. If the source database is modified by an
         5473  +** and sqlite3_backup_step() returns [SQLITE_DONE].  ^Every call to
         5474  +** sqlite3_backup_step() obtains a [shared lock] on the source database that
         5475  +** lasts for the duration of the sqlite3_backup_step() call.
         5476  +** ^Because the source database is not locked between calls to
         5477  +** sqlite3_backup_step(), the source database may be modified mid-way
         5478  +** through the backup process.  ^If the source database is modified by an
  5407   5479   ** external process or via a database connection other than the one being
  5408         -** used by the backup operation, then the backup will be transparently
  5409         -** restarted by the next call to sqlite3_backup_step(). If the source 
         5480  +** used by the backup operation, then the backup will be automatically
         5481  +** restarted by the next call to sqlite3_backup_step(). ^If the source 
  5410   5482   ** database is modified by the using the same database connection as is used
  5411         -** by the backup operation, then the backup database is transparently 
         5483  +** by the backup operation, then the backup database is automatically
  5412   5484   ** updated at the same time.
  5413   5485   **
  5414   5486   ** <b>sqlite3_backup_finish()</b>
  5415   5487   **
  5416         -** Once sqlite3_backup_step() has returned [SQLITE_DONE], or when the 
  5417         -** application wishes to abandon the backup operation, the [sqlite3_backup]
  5418         -** object should be passed to sqlite3_backup_finish(). This releases all
  5419         -** resources associated with the backup operation. If sqlite3_backup_step()
  5420         -** has not yet returned [SQLITE_DONE], then any active write-transaction on the
  5421         -** destination database is rolled back. The [sqlite3_backup] object is invalid
         5488  +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the 
         5489  +** application wishes to abandon the backup operation, the application
         5490  +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish().
         5491  +** ^The sqlite3_backup_finish() interfaces releases all
         5492  +** resources associated with the [sqlite3_backup] object. 
         5493  +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
         5494  +** active write-transaction on the destination database is rolled back.
         5495  +** The [sqlite3_backup] object is invalid
  5422   5496   ** and may not be used following a call to sqlite3_backup_finish().
  5423   5497   **
  5424         -** The value returned by sqlite3_backup_finish is [SQLITE_OK] if no error
  5425         -** occurred, regardless or whether or not sqlite3_backup_step() was called
  5426         -** a sufficient number of times to complete the backup operation. Or, if
  5427         -** an out-of-memory condition or IO error occured during a call to
  5428         -** sqlite3_backup_step() then [SQLITE_NOMEM] or an
  5429         -** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] error code
  5430         -** is returned. In this case the error code and an error message are
  5431         -** written to the destination [database connection].
         5498  +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
         5499  +** sqlite3_backup_step() errors occurred, regardless or whether or not
         5500  +** sqlite3_backup_step() completed.
         5501  +** ^If an out-of-memory condition or IO error occurred during any prior
         5502  +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
         5503  +** sqlite3_backup_finish() returns the corresponding [error code].
  5432   5504   **
  5433         -** A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() is
  5434         -** not a permanent error and does not affect the return value of
         5505  +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step()
         5506  +** is not a permanent error and does not affect the return value of
  5435   5507   ** sqlite3_backup_finish().
  5436   5508   **
  5437   5509   ** <b>sqlite3_backup_remaining(), sqlite3_backup_pagecount()</b>
  5438   5510   **
  5439         -** Each call to sqlite3_backup_step() sets two values stored internally
  5440         -** by an [sqlite3_backup] object. The number of pages still to be backed
  5441         -** up, which may be queried by sqlite3_backup_remaining(), and the total
  5442         -** number of pages in the source database file, which may be queried by
  5443         -** sqlite3_backup_pagecount().
         5511  +** ^Each call to sqlite3_backup_step() sets two values inside
         5512  +** the [sqlite3_backup] object: the number of pages still to be backed
         5513  +** up and the total number of pages in the source databae file.
         5514  +** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
         5515  +** retrieve these two values, respectively.
  5444   5516   **
  5445         -** The values returned by these functions are only updated by
  5446         -** sqlite3_backup_step(). If the source database is modified during a backup
         5517  +** ^The values returned by these functions are only updated by
         5518  +** sqlite3_backup_step(). ^If the source database is modified during a backup
  5447   5519   ** operation, then the values are not updated to account for any extra
  5448   5520   ** pages that need to be updated or the size of the source database file
  5449   5521   ** changing.
  5450   5522   **
  5451   5523   ** <b>Concurrent Usage of Database Handles</b>
  5452   5524   **
  5453         -** The source [database connection] may be used by the application for other
         5525  +** ^The source [database connection] may be used by the application for other
  5454   5526   ** purposes while a backup operation is underway or being initialized.
  5455         -** If SQLite is compiled and configured to support threadsafe database
         5527  +** ^If SQLite is compiled and configured to support threadsafe database
  5456   5528   ** connections, then the source database connection may be used concurrently
  5457   5529   ** from within other threads.
  5458   5530   **
  5459         -** However, the application must guarantee that the destination database
  5460         -** connection handle is not passed to any other API (by any thread) after 
         5531  +** However, the application must guarantee that the destination 
         5532  +** [database connection] is not passed to any other API (by any thread) after 
  5461   5533   ** sqlite3_backup_init() is called and before the corresponding call to
  5462         -** sqlite3_backup_finish(). Unfortunately SQLite does not currently check
  5463         -** for this, if the application does use the destination [database connection]
  5464         -** for some other purpose during a backup operation, things may appear to
  5465         -** work correctly but in fact be subtly malfunctioning.  Use of the
  5466         -** destination database connection while a backup is in progress might
  5467         -** also cause a mutex deadlock.
         5534  +** sqlite3_backup_finish().  SQLite does not currently check to see
         5535  +** if the application incorrectly accesses the destination [database connection]
         5536  +** and so no error code is reported, but the operations may malfunction
         5537  +** nevertheless.  Use of the destination database connection while a
         5538  +** backup is in progress might also also cause a mutex deadlock.
  5468   5539   **
  5469         -** Furthermore, if running in [shared cache mode], the application must
         5540  +** If running in [shared cache mode], the application must
  5470   5541   ** guarantee that the shared cache used by the destination database
  5471   5542   ** is not accessed while the backup is running. In practice this means
  5472         -** that the application must guarantee that the file-system file being 
         5543  +** that the application must guarantee that the disk file being 
  5473   5544   ** backed up to is not accessed by any connection within the process,
  5474   5545   ** not just the specific connection that was passed to sqlite3_backup_init().
  5475   5546   **
  5476   5547   ** The [sqlite3_backup] object itself is partially threadsafe. Multiple 
  5477   5548   ** threads may safely make multiple concurrent calls to sqlite3_backup_step().
  5478   5549   ** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount()
  5479   5550   ** APIs are not strictly speaking threadsafe. If they are invoked at the
  5480   5551   ** same time as another thread is invoking sqlite3_backup_step() it is
  5481   5552   ** possible that they return invalid values.
  5482   5553   */
  5483         -sqlite3_backup *sqlite3_backup_init(
         5554  +SQLITE_API sqlite3_backup *sqlite3_backup_init(
  5484   5555     sqlite3 *pDest,                        /* Destination database handle */
  5485   5556     const char *zDestName,                 /* Destination database name */
  5486   5557     sqlite3 *pSource,                      /* Source database handle */
  5487   5558     const char *zSourceName                /* Source database name */
  5488   5559   );
  5489         -int sqlite3_backup_step(sqlite3_backup *p, int nPage);
  5490         -int sqlite3_backup_finish(sqlite3_backup *p);
  5491         -int sqlite3_backup_remaining(sqlite3_backup *p);
  5492         -int sqlite3_backup_pagecount(sqlite3_backup *p);
         5560  +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
         5561  +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
         5562  +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
         5563  +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
  5493   5564   
  5494   5565   /*
  5495   5566   ** CAPI3REF: Unlock Notification
  5496   5567   ** EXPERIMENTAL
  5497   5568   **
  5498         -** When running in shared-cache mode, a database operation may fail with
         5569  +** ^When running in shared-cache mode, a database operation may fail with
  5499   5570   ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
  5500   5571   ** individual tables within the shared-cache cannot be obtained. See
  5501   5572   ** [SQLite Shared-Cache Mode] for a description of shared-cache locking. 
  5502         -** This API may be used to register a callback that SQLite will invoke 
         5573  +** ^This API may be used to register a callback that SQLite will invoke 
  5503   5574   ** when the connection currently holding the required lock relinquishes it.
  5504         -** This API is only available if the library was compiled with the
         5575  +** ^This API is only available if the library was compiled with the
  5505   5576   ** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
  5506   5577   **
  5507   5578   ** See Also: [Using the SQLite Unlock Notification Feature].
  5508   5579   **
  5509         -** Shared-cache locks are released when a database connection concludes
         5580  +** ^Shared-cache locks are released when a database connection concludes
  5510   5581   ** its current transaction, either by committing it or rolling it back. 
  5511   5582   **
  5512         -** When a connection (known as the blocked connection) fails to obtain a
         5583  +** ^When a connection (known as the blocked connection) fails to obtain a
  5513   5584   ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
  5514   5585   ** identity of the database connection (the blocking connection) that
  5515         -** has locked the required resource is stored internally. After an 
         5586  +** has locked the required resource is stored internally. ^After an 
  5516   5587   ** application receives an SQLITE_LOCKED error, it may call the
  5517   5588   ** sqlite3_unlock_notify() method with the blocked connection handle as 
  5518   5589   ** the first argument to register for a callback that will be invoked
  5519         -** when the blocking connections current transaction is concluded. The
         5590  +** when the blocking connections current transaction is concluded. ^The
  5520   5591   ** callback is invoked from within the [sqlite3_step] or [sqlite3_close]
  5521   5592   ** call that concludes the blocking connections transaction.
  5522   5593   **
  5523         -** If sqlite3_unlock_notify() is called in a multi-threaded application,
         5594  +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
  5524   5595   ** there is a chance that the blocking connection will have already
  5525   5596   ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
  5526   5597   ** If this happens, then the specified callback is invoked immediately,
  5527         -** from within the call to sqlite3_unlock_notify().
         5598  +** from within the call to sqlite3_unlock_notify().)^
  5528   5599   **
  5529         -** If the blocked connection is attempting to obtain a write-lock on a
         5600  +** ^If the blocked connection is attempting to obtain a write-lock on a
  5530   5601   ** shared-cache table, and more than one other connection currently holds
  5531   5602   ** a read-lock on the same table, then SQLite arbitrarily selects one of 
  5532   5603   ** the other connections to use as the blocking connection.
  5533   5604   **
  5534         -** There may be at most one unlock-notify callback registered by a 
         5605  +** ^(There may be at most one unlock-notify callback registered by a 
  5535   5606   ** blocked connection. If sqlite3_unlock_notify() is called when the
  5536   5607   ** blocked connection already has a registered unlock-notify callback,
  5537         -** then the new callback replaces the old. If sqlite3_unlock_notify() is
         5608  +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
  5538   5609   ** called with a NULL pointer as its second argument, then any existing
  5539         -** unlock-notify callback is cancelled. The blocked connections 
         5610  +** unlock-notify callback is cancelled. ^The blocked connections 
  5540   5611   ** unlock-notify callback may also be canceled by closing the blocked
  5541   5612   ** connection using [sqlite3_close()].
  5542   5613   **
  5543   5614   ** The unlock-notify callback is not reentrant. If an application invokes
  5544   5615   ** any sqlite3_xxx API functions from within an unlock-notify callback, a
  5545   5616   ** crash or deadlock may be the result.
  5546   5617   **
  5547         -** Unless deadlock is detected (see below), sqlite3_unlock_notify() always
         5618  +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always
  5548   5619   ** returns SQLITE_OK.
  5549   5620   **
  5550   5621   ** <b>Callback Invocation Details</b>
  5551   5622   **
  5552   5623   ** When an unlock-notify callback is registered, the application provides a 
  5553   5624   ** single void* pointer that is passed to the callback when it is invoked.
  5554   5625   ** However, the signature of the callback function allows SQLite to pass
  5555   5626   ** it an array of void* context pointers. The first argument passed to
  5556   5627   ** an unlock-notify callback is a pointer to an array of void* pointers,
  5557   5628   ** and the second is the number of entries in the array.
  5558   5629   **
  5559   5630   ** When a blocking connections transaction is concluded, there may be
  5560   5631   ** more than one blocked connection that has registered for an unlock-notify
  5561         -** callback. If two or more such blocked connections have specified the
         5632  +** callback. ^If two or more such blocked connections have specified the
  5562   5633   ** same callback function, then instead of invoking the callback function
  5563   5634   ** multiple times, it is invoked once with the set of void* context pointers
  5564   5635   ** specified by the blocked connections bundled together into an array.
  5565   5636   ** This gives the application an opportunity to prioritize any actions 
  5566   5637   ** related to the set of unblocked database connections.
  5567   5638   **
  5568   5639   ** <b>Deadlock Detection</b>
................................................................................
  5572   5643   ** action (a reasonable assumption), then using this API may cause the
  5573   5644   ** application to deadlock. For example, if connection X is waiting for
  5574   5645   ** connection Y's transaction to be concluded, and similarly connection
  5575   5646   ** Y is waiting on connection X's transaction, then neither connection
  5576   5647   ** will proceed and the system may remain deadlocked indefinitely.
  5577   5648   **
  5578   5649   ** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock
  5579         -** detection. If a given call to sqlite3_unlock_notify() would put the
         5650  +** detection. ^If a given call to sqlite3_unlock_notify() would put the
  5580   5651   ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
  5581   5652   ** unlock-notify callback is registered. The system is said to be in
  5582   5653   ** a deadlocked state if connection A has registered for an unlock-notify
  5583   5654   ** callback on the conclusion of connection B's transaction, and connection
  5584   5655   ** B has itself registered for an unlock-notify callback when connection
  5585         -** A's transaction is concluded. Indirect deadlock is also detected, so
         5656  +** A's transaction is concluded. ^Indirect deadlock is also detected, so
  5586   5657   ** the system is also considered to be deadlocked if connection B has
  5587   5658   ** registered for an unlock-notify callback on the conclusion of connection
  5588         -** C's transaction, where connection C is waiting on connection A. Any
         5659  +** C's transaction, where connection C is waiting on connection A. ^Any
  5589   5660   ** number of levels of indirection are allowed.
  5590   5661   **
  5591   5662   ** <b>The "DROP TABLE" Exception</b>
  5592   5663   **
  5593   5664   ** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost 
  5594   5665   ** always appropriate to call sqlite3_unlock_notify(). There is however,
  5595   5666   ** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement,
................................................................................
  5597   5668   ** that belong to the same connection. If there are, SQLITE_LOCKED is
  5598   5669   ** returned. In this case there is no "blocking connection", so invoking
  5599   5670   ** sqlite3_unlock_notify() results in the unlock-notify callback being
  5600   5671   ** invoked immediately. If the application then re-attempts the "DROP TABLE"
  5601   5672   ** or "DROP INDEX" query, an infinite loop might be the result.
  5602   5673   **
  5603   5674   ** One way around this problem is to check the extended error code returned
  5604         -** by an sqlite3_step() call. If there is a blocking connection, then the
         5675  +** by an sqlite3_step() call. ^(If there is a blocking connection, then the
  5605   5676   ** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
  5606   5677   ** the special "DROP TABLE/INDEX" case, the extended error code is just 
  5607         -** SQLITE_LOCKED.
         5678  +** SQLITE_LOCKED.)^
  5608   5679   */
  5609         -int sqlite3_unlock_notify(
         5680  +SQLITE_API int sqlite3_unlock_notify(
  5610   5681     sqlite3 *pBlocked,                          /* Waiting connection */
  5611   5682     void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
  5612   5683     void *pNotifyArg                            /* Argument to pass to xNotify */
  5613   5684   );
  5614   5685   
         5686  +
         5687  +/*
         5688  +** CAPI3REF: String Comparison
         5689  +** EXPERIMENTAL
         5690  +**
         5691  +** ^The [sqlite3_strnicmp()] API allows applications and extensions to
         5692  +** compare the contents of two buffers containing UTF-8 strings in a
         5693  +** case-indendent fashion, using the same definition of case independence 
         5694  +** that SQLite uses internally when comparing identifiers.
         5695  +*/
         5696  +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
         5697  +
         5698  +/*
         5699  +** CAPI3REF: Error Logging Interface
         5700  +** EXPERIMENTAL
         5701  +**
         5702  +** ^The [sqlite3_log()] interface writes a message into the error log
         5703  +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].
         5704  +** ^If logging is enabled, the zFormat string and subsequent arguments are
         5705  +** passed through to [sqlite3_vmprintf()] to generate the final output string.
         5706  +**
         5707  +** The sqlite3_log() interface is intended for use by extensions such as
         5708  +** virtual tables, collating functions, and SQL functions.  While there is
         5709  +** nothing to prevent an application from calling sqlite3_log(), doing so
         5710  +** is considered bad form.
         5711  +**
         5712  +** The zFormat string must not be NULL.
         5713  +**
         5714  +** To avoid deadlocks and other threading problems, the sqlite3_log() routine
         5715  +** will not use dynamically allocated memory.  The log message is stored in
         5716  +** a fixed-length buffer on the stack.  If the log message is longer than
         5717  +** a few hundred characters, it will be truncated to the length of the
         5718  +** buffer.
         5719  +*/
         5720  +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
         5721  +
  5615   5722   /*
  5616   5723   ** Undo the hack that converts floating point types to integer for
  5617   5724   ** builds on processors without floating point support.
  5618   5725   */
  5619   5726   #ifdef SQLITE_OMIT_FLOATING_POINT
  5620   5727   # undef double
  5621   5728   #endif
  5622   5729   
  5623   5730   #ifdef __cplusplus
  5624   5731   }  /* End of the 'extern "C"' block */
  5625   5732   #endif
  5626   5733   #endif
         5734  +

Changes to SQLite.Interop/src/sqlite3ext.h.

    10     10   **
    11     11   *************************************************************************
    12     12   ** This header file defines the SQLite interface for use by
    13     13   ** shared libraries that want to be imported as extensions into
    14     14   ** an SQLite instance.  Shared libraries that intend to be loaded
    15     15   ** as extensions by SQLite should #include this file instead of 
    16     16   ** sqlite3.h.
    17         -**
    18         -** @(#) $Id: sqlite3ext.h,v 1.18 2009/06/29 22:59:09 rmsimpson Exp $
    19     17   */
    20     18   #ifndef _SQLITE3EXT_H_
    21     19   #define _SQLITE3EXT_H_
    22     20   #include "sqlite3.h"
    23     21   
    24     22   typedef struct sqlite3_api_routines sqlite3_api_routines;
    25     23   

Changes to SQLite.NET.sln.

     5      5   	ProjectSection(SolutionItems) = preProject
     6      6   		readme.htm = readme.htm
     7      7   	EndProjectSection
     8      8   EndProject
     9      9   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite - Compact", "System.Data.SQLite\System.Data.SQLite - Compact.csproj", "{AC139951-261A-4463-B6FA-AEBC25283A66}"
    10     10   EndProject
    11     11   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "test", "test\test.csproj", "{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}"
           12  +	ProjectSection(ProjectDependencies) = postProject
           13  +		{10B51CE8-A838-44DE-BD82-B658F0296F80} = {10B51CE8-A838-44DE-BD82-B658F0296F80}
           14  +	EndProjectSection
    12     15   EndProject
    13     16   Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SQLite.Interop", "SQLite.Interop\SQLite.Interop.vcproj", "{10B51CE8-A838-44DE-BD82-B658F0296F80}"
    14     17   	ProjectSection(ProjectDependencies) = postProject
           18  +		{AC139951-261A-4463-B6FA-AEBC25283A66} = {AC139951-261A-4463-B6FA-AEBC25283A66}
           19  +		{AC139952-261A-4463-B6FA-AEBC25283A66} = {AC139952-261A-4463-B6FA-AEBC25283A66}
    15     20   		{AC139952-261A-4463-B6FA-AEBC25284A66} = {AC139952-261A-4463-B6FA-AEBC25284A66}
    16     21   	EndProjectSection
    17     22   EndProject
    18     23   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "testce", "testce\testce.csproj", "{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}"
           24  +	ProjectSection(ProjectDependencies) = postProject
           25  +		{AC139951-261A-4463-B6FA-AEBC25283A66} = {AC139951-261A-4463-B6FA-AEBC25283A66}
           26  +		{10B51CE8-A838-44DE-BD82-B658F0296F80} = {10B51CE8-A838-44DE-BD82-B658F0296F80}
           27  +	EndProjectSection
    19     28   EndProject
    20     29   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite - ManagedOnly", "System.Data.SQLite\System.Data.SQLite - ManagedOnly.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    21     30   EndProject
    22     31   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Linq", "System.Data.SQLite.Linq\System.Data.SQLite.Linq.csproj", "{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}"
    23     32   	ProjectSection(ProjectDependencies) = postProject
    24     33   		{10B51CE8-A838-44DE-BD82-B658F0296F80} = {10B51CE8-A838-44DE-BD82-B658F0296F80}
    25     34   	EndProjectSection
    26     35   EndProject
    27     36   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "testlinq", "testlinq\testlinq.csproj", "{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}"
           37  +	ProjectSection(ProjectDependencies) = postProject
           38  +		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D} = {E6BF9F74-58E2-413B-A7CE-EA653ECB728D}
           39  +	EndProjectSection
    28     40   EndProject
    29     41   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite - Netmodule", "System.Data.SQLite\System.Data.SQLite - Netmodule.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    30     42   EndProject
    31     43   Global
    32     44   	GlobalSection(SolutionConfigurationPlatforms) = preSolution
    33         -		Debug - Stock|Any CPU = Debug - Stock|Any CPU
    34     45   		Debug - Stock|Compact Framework (ARMV4) = Debug - Stock|Compact Framework (ARMV4)
    35     46   		Debug - Stock|Itanium = Debug - Stock|Itanium
    36         -		Debug - Stock|Mixed Platforms = Debug - Stock|Mixed Platforms
    37     47   		Debug - Stock|Win32 = Debug - Stock|Win32
    38     48   		Debug - Stock|x64 = Debug - Stock|x64
    39         -		Debug|Any CPU = Debug|Any CPU
    40     49   		Debug|Compact Framework (ARMV4) = Debug|Compact Framework (ARMV4)
    41     50   		Debug|Itanium = Debug|Itanium
    42         -		Debug|Mixed Platforms = Debug|Mixed Platforms
    43     51   		Debug|Win32 = Debug|Win32
    44     52   		Debug|x64 = Debug|x64
    45         -		Release - Stock|Any CPU = Release - Stock|Any CPU
    46     53   		Release - Stock|Compact Framework (ARMV4) = Release - Stock|Compact Framework (ARMV4)
    47     54   		Release - Stock|Itanium = Release - Stock|Itanium
    48         -		Release - Stock|Mixed Platforms = Release - Stock|Mixed Platforms
    49     55   		Release - Stock|Win32 = Release - Stock|Win32
    50     56   		Release - Stock|x64 = Release - Stock|x64
    51         -		Release|Any CPU = Release|Any CPU
    52     57   		Release|Compact Framework (ARMV4) = Release|Compact Framework (ARMV4)
    53     58   		Release|Itanium = Release|Itanium
    54         -		Release|Mixed Platforms = Release|Mixed Platforms
    55     59   		Release|Win32 = Release|Win32
    56     60   		Release|x64 = Release|x64
    57     61   	EndGlobalSection
    58     62   	GlobalSection(ProjectConfigurationPlatforms) = postSolution
    59         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
    60         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
    61     63   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
    62     64   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Compact Framework (ARMV4).Build.0 = Debug|Any CPU
    63     65   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
    64         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
    65         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
    66     66   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
    67     67   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
    68         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
    69         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Any CPU.Build.0 = Debug|Any CPU
    70     68   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
    71     69   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Compact Framework (ARMV4).Build.0 = Debug|Any CPU
    72     70   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Itanium.ActiveCfg = Debug|Any CPU
    73         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
    74         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
    75     71   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|Win32.ActiveCfg = Debug|Any CPU
    76     72   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Debug|x64.ActiveCfg = Debug|Any CPU
    77         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
    78         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
    79     73   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
    80     74   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Compact Framework (ARMV4).Build.0 = Release|Any CPU
    81     75   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
    82         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
    83         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
    84     76   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
    85     77   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release - Stock|x64.ActiveCfg = Release|Any CPU
    86         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Any CPU.ActiveCfg = Release|Any CPU
    87         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Any CPU.Build.0 = Release|Any CPU
    88     78   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
    89     79   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Compact Framework (ARMV4).Build.0 = Release|Any CPU
    90     80   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Itanium.ActiveCfg = Release|Any CPU
    91         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
    92         -		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Mixed Platforms.Build.0 = Release|Any CPU
    93     81   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|Win32.ActiveCfg = Release|Any CPU
    94     82   		{AC139951-261A-4463-B6FA-AEBC25283A66}.Release|x64.ActiveCfg = Release|Any CPU
    95         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
    96         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
    97     83   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
    98     84   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Itanium.ActiveCfg = Debug|Itanium
    99     85   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Itanium.Build.0 = Debug|Itanium
   100         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   101         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   102         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Win32.ActiveCfg = Debug|x86
   103         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Win32.Build.0 = Debug|x86
           86  +		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
           87  +		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|Win32.Build.0 = Debug|Any CPU
   104     88   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|x64.ActiveCfg = Debug|x64
   105     89   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug - Stock|x64.Build.0 = Debug|x64
   106         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   107         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Any CPU.Build.0 = Debug|Any CPU
   108     90   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   109     91   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Itanium.ActiveCfg = Debug|Itanium
   110     92   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Itanium.Build.0 = Debug|Itanium
   111         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   112         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   113     93   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Win32.ActiveCfg = Debug|x86
   114     94   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|Win32.Build.0 = Debug|x86
   115     95   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|x64.ActiveCfg = Debug|x64
   116     96   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Debug|x64.Build.0 = Debug|x64
   117         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   118         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   119     97   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   120     98   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Itanium.ActiveCfg = Release|Itanium
   121     99   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Itanium.Build.0 = Release|Itanium
   122         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   123         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   124    100   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
   125    101   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|Win32.Build.0 = Release|Any CPU
   126    102   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|x64.ActiveCfg = Release|x64
   127    103   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release - Stock|x64.Build.0 = Release|x64
   128         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Any CPU.ActiveCfg = Release|Any CPU
   129         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Any CPU.Build.0 = Release|Any CPU
   130    104   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   131    105   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Itanium.ActiveCfg = Release|Itanium
   132    106   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Itanium.Build.0 = Release|Itanium
   133         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   134         -		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   135    107   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Win32.ActiveCfg = Release|x86
   136    108   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|Win32.Build.0 = Release|x86
   137    109   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|x64.ActiveCfg = Release|x64
   138    110   		{E27B1B1E-19C0-45E8-AA74-B6E1C041A130}.Release|x64.Build.0 = Release|x64
   139         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Any CPU.ActiveCfg = Debug|x64
   140    111   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = StockDebug|Pocket PC 2003 (ARMV4)
   141    112   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Compact Framework (ARMV4).Build.0 = StockDebug|Pocket PC 2003 (ARMV4)
   142    113   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Compact Framework (ARMV4).Deploy.0 = StockDebug|Pocket PC 2003 (ARMV4)
   143    114   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Itanium.ActiveCfg = Debug|Itanium
   144         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Itanium.Build.0 = Debug|Itanium
   145    115   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Itanium.Deploy.0 = Debug|Itanium
   146         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|x64
   147         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Mixed Platforms.Build.0 = Debug|x64
   148    116   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Win32.ActiveCfg = StockDebug|Win32
   149    117   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|Win32.Deploy.0 = StockDebug|Win32
   150    118   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|x64.ActiveCfg = Debug|x64
   151         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|x64.Build.0 = Debug|x64
   152    119   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug - Stock|x64.Deploy.0 = Debug|x64
   153         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Any CPU.ActiveCfg = Debug|x64
   154    120   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Pocket PC 2003 (ARMV4)
   155    121   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Compact Framework (ARMV4).Build.0 = Debug|Pocket PC 2003 (ARMV4)
   156    122   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Compact Framework (ARMV4).Deploy.0 = Debug|Pocket PC 2003 (ARMV4)
   157    123   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Itanium.ActiveCfg = Debug|Itanium
   158    124   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Itanium.Build.0 = Debug|Itanium
   159    125   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Itanium.Deploy.0 = Debug|Itanium
   160         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Mixed Platforms.ActiveCfg = Debug|x64
   161         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Mixed Platforms.Build.0 = Debug|x64
   162    126   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Win32.ActiveCfg = Debug|Win32
   163    127   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Win32.Build.0 = Debug|Win32
   164    128   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|Win32.Deploy.0 = Debug|Win32
   165    129   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|x64.ActiveCfg = Debug|x64
   166    130   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|x64.Build.0 = Debug|x64
   167    131   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Debug|x64.Deploy.0 = Debug|x64
   168         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Any CPU.ActiveCfg = Release|x64
   169    132   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Pocket PC 2003 (ARMV4)
   170    133   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Compact Framework (ARMV4).Build.0 = Release|Pocket PC 2003 (ARMV4)
   171    134   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Compact Framework (ARMV4).Deploy.0 = Release|Pocket PC 2003 (ARMV4)
   172    135   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Itanium.ActiveCfg = Release|Itanium
   173         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Itanium.Build.0 = Release|Itanium
   174         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Mixed Platforms.ActiveCfg = Release|x64
   175         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Mixed Platforms.Build.0 = Release|x64
   176    136   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|Win32.ActiveCfg = Release|Win32
   177    137   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|x64.ActiveCfg = Release|x64
   178         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release - Stock|x64.Build.0 = Release|x64
   179         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Any CPU.ActiveCfg = Release|x64
   180    138   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Pocket PC 2003 (ARMV4)
   181    139   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Compact Framework (ARMV4).Build.0 = Release|Pocket PC 2003 (ARMV4)
   182    140   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Itanium.ActiveCfg = Release|Itanium
   183    141   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Itanium.Build.0 = Release|Itanium
   184         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Mixed Platforms.ActiveCfg = Release|x64
   185         -		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Mixed Platforms.Build.0 = Release|x64
   186    142   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Win32.ActiveCfg = Release|Win32
   187    143   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|Win32.Build.0 = Release|Win32
   188    144   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|x64.ActiveCfg = Release|x64
   189    145   		{10B51CE8-A838-44DE-BD82-B658F0296F80}.Release|x64.Build.0 = Release|x64
   190         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
   191         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
   192         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Any CPU.Deploy.0 = Debug|Any CPU
   193    146   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   194    147   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Compact Framework (ARMV4).Build.0 = Debug|Any CPU
   195    148   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Compact Framework (ARMV4).Deploy.0 = Debug|Any CPU
   196    149   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
   197         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   198         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   199         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Mixed Platforms.Deploy.0 = Debug|Any CPU
   200    150   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
   201    151   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
   202         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   203         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Any CPU.Build.0 = Debug|Any CPU
   204         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
   205    152   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   206    153   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Compact Framework (ARMV4).Build.0 = Debug|Any CPU
   207    154   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Compact Framework (ARMV4).Deploy.0 = Debug|Any CPU
   208    155   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Itanium.ActiveCfg = Debug|Any CPU
   209         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   210         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   211         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Mixed Platforms.Deploy.0 = Debug|Any CPU
   212    156   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|Win32.ActiveCfg = Debug|Any CPU
   213    157   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Debug|x64.ActiveCfg = Debug|Any CPU
   214         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   215         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   216         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Any CPU.Deploy.0 = Release|Any CPU
   217    158   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   218    159   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Compact Framework (ARMV4).Build.0 = Release|Any CPU
   219    160   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Compact Framework (ARMV4).Deploy.0 = Release|Any CPU
   220    161   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
   221         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   222         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   223         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Mixed Platforms.Deploy.0 = Release|Any CPU
   224    162   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
   225    163   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release - Stock|x64.ActiveCfg = Release|Any CPU
   226         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Any CPU.ActiveCfg = Release|Any CPU
   227         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Any CPU.Build.0 = Release|Any CPU
   228         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Any CPU.Deploy.0 = Release|Any CPU
   229    164   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   230    165   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Compact Framework (ARMV4).Build.0 = Release|Any CPU
   231    166   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Compact Framework (ARMV4).Deploy.0 = Release|Any CPU
   232    167   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Itanium.ActiveCfg = Release|Any CPU
   233         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   234         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   235         -		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Mixed Platforms.Deploy.0 = Release|Any CPU
   236    168   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|Win32.ActiveCfg = Release|Any CPU
   237    169   		{B86CE504-C4E4-496F-A0F0-E613BCFD3DF7}.Release|x64.ActiveCfg = Release|Any CPU
   238         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
   239         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
   240    170   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   241    171   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
   242    172   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Itanium.Build.0 = Debug|Any CPU
   243         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   244         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   245    173   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Win32.ActiveCfg = StockDebug|Any CPU
   246    174   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|Win32.Build.0 = StockDebug|Any CPU
   247    175   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
   248    176   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug - Stock|x64.Build.0 = Debug|Any CPU
   249         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   250         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Any CPU.Build.0 = Debug|Any CPU
   251    177   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   252    178   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Itanium.ActiveCfg = Debug|Any CPU
   253    179   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Itanium.Build.0 = Debug|Any CPU
   254         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   255         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   256    180   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Win32.ActiveCfg = Debug|Any CPU
   257    181   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|Win32.Build.0 = Debug|Any CPU
   258    182   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|x64.ActiveCfg = Debug|Any CPU
   259    183   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Debug|x64.Build.0 = Debug|Any CPU
   260         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   261         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   262    184   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   263    185   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
   264    186   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Itanium.Build.0 = Release|Any CPU
   265         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   266         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   267    187   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Win32.ActiveCfg = StockRelease|Any CPU
   268    188   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|Win32.Build.0 = StockRelease|Any CPU
   269    189   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|x64.ActiveCfg = Release|Any CPU
   270    190   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release - Stock|x64.Build.0 = Release|Any CPU
   271         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Any CPU.ActiveCfg = Release|Any CPU
   272         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Any CPU.Build.0 = Release|Any CPU
   273    191   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   274    192   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Itanium.ActiveCfg = Release|Any CPU
   275         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   276         -		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   277    193   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|Win32.ActiveCfg = Release|Any CPU
   278    194   		{AC139952-261A-4463-B6FA-AEBC25283A66}.Release|x64.ActiveCfg = Release|Any CPU
   279         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
   280         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
   281    195   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   282    196   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
   283    197   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Itanium.Build.0 = Debug|Any CPU
   284         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   285         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   286    198   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
   287    199   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|Win32.Build.0 = Debug|Any CPU
   288    200   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
   289    201   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug - Stock|x64.Build.0 = Debug|Any CPU
   290         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   291         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Any CPU.Build.0 = Debug|Any CPU
   292    202   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   293    203   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Itanium.ActiveCfg = Debug|Any CPU
   294    204   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Itanium.Build.0 = Debug|Any CPU
   295         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   296         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   297    205   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Win32.ActiveCfg = Debug|Any CPU
   298    206   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|Win32.Build.0 = Debug|Any CPU
   299    207   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|x64.ActiveCfg = Debug|Any CPU
   300    208   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Debug|x64.Build.0 = Debug|Any CPU
   301         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   302         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   303    209   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   304    210   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
   305    211   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Itanium.Build.0 = Release|Any CPU
   306         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   307         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   308    212   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
   309    213   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|Win32.Build.0 = Release|Any CPU
   310    214   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|x64.ActiveCfg = Release|Any CPU
   311    215   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release - Stock|x64.Build.0 = Release|Any CPU
   312         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Any CPU.ActiveCfg = Release|Any CPU
   313         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Any CPU.Build.0 = Release|Any CPU
   314    216   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   315    217   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Itanium.ActiveCfg = Release|Any CPU
   316    218   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Itanium.Build.0 = Release|Any CPU
   317         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   318         -		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   319    219   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Win32.ActiveCfg = Release|Any CPU
   320    220   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|Win32.Build.0 = Release|Any CPU
   321    221   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|x64.ActiveCfg = Release|Any CPU
   322    222   		{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}.Release|x64.Build.0 = Release|Any CPU
   323         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
   324         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
   325    223   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   326    224   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
   327         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   328         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   329    225   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
   330    226   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
   331         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   332         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
   333    227   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   334    228   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Itanium.ActiveCfg = Debug|Any CPU
   335         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   336         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   337    229   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Win32.ActiveCfg = Debug|Any CPU
   338         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|Win32.Build.0 = Debug|Any CPU
   339    230   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Debug|x64.ActiveCfg = Debug|Any CPU
   340         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   341         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   342    231   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   343    232   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
   344         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   345         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   346    233   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
   347    234   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release - Stock|x64.ActiveCfg = Release|Any CPU
   348         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
   349         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Any CPU.Build.0 = Release|Any CPU
   350    235   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   351    236   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Itanium.ActiveCfg = Release|Any CPU
   352         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   353         -		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   354    237   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|Win32.ActiveCfg = Release|Any CPU
   355    238   		{9D3CF7A6-092A-4B05-B0E4-BEF6944525B3}.Release|x64.ActiveCfg = Release|Any CPU
   356         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Any CPU.ActiveCfg = Debug|Any CPU
   357         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Any CPU.Build.0 = Debug|Any CPU
   358    239   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   359    240   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Itanium.ActiveCfg = Debug|Any CPU
   360         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Mixed Platforms.ActiveCfg = Debug|Any CPU
   361         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Mixed Platforms.Build.0 = Debug|Any CPU
   362    241   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|Win32.ActiveCfg = Debug|Any CPU
   363    242   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug - Stock|x64.ActiveCfg = Debug|Any CPU
   364         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   365         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.Build.0 = Debug|Any CPU
   366    243   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Compact Framework (ARMV4).ActiveCfg = Debug|Any CPU
   367    244   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Itanium.ActiveCfg = Debug|Any CPU
   368         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   369         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   370    245   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Win32.ActiveCfg = Debug|Any CPU
   371    246   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|x64.ActiveCfg = Debug|Any CPU
   372         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Any CPU.ActiveCfg = Release|Any CPU
   373         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Any CPU.Build.0 = Release|Any CPU
   374    247   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   375    248   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Itanium.ActiveCfg = Release|Any CPU
   376         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Mixed Platforms.ActiveCfg = Release|Any CPU
   377         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Mixed Platforms.Build.0 = Release|Any CPU
   378    249   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|Win32.ActiveCfg = Release|Any CPU
   379    250   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release - Stock|x64.ActiveCfg = Release|Any CPU
   380         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Any CPU.ActiveCfg = Release|Any CPU
   381         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Any CPU.Build.0 = Release|Any CPU
   382    251   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Compact Framework (ARMV4).ActiveCfg = Release|Any CPU
   383    252   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Itanium.ActiveCfg = Release|Any CPU
   384    253   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Itanium.Build.0 = Release|Any CPU
   385         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
   386         -		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Mixed Platforms.Build.0 = Release|Any CPU
   387    254   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Win32.ActiveCfg = Release|Any CPU
   388    255   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|Win32.Build.0 = Release|Any CPU
   389    256   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|x64.ActiveCfg = Release|Any CPU
   390    257   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Release|x64.Build.0 = Release|Any CPU
   391    258   	EndGlobalSection
   392    259   	GlobalSection(SolutionProperties) = preSolution
   393    260   		HideSolutionNode = FALSE
   394    261   	EndGlobalSection
   395    262   EndGlobal

Changes to SQLite.NET.suo.

cannot compute difference between binary files

Changes to System.Data.SQLite.Linq/SQL.

     1         -//---------------------------------------------------------------------
     2         -// <copyright file="DmlSqlGenerator.cs" company="Microsoft">
     3         -//      Copyright (c) Microsoft Corporation.  All rights reserved.
     4         -// </copyright>
     5         -//---------------------------------------------------------------------
            1  +/********************************************************
            2  + * ADO.NET 2.0 Data Provider for SQLite Version 3.X
            3  + * Written by Robert Simpson (robert@blackcastlesoft.com)
            4  + * 
            5  + * Released to the public domain, use at your own risk!
            6  + ********************************************************/
     6      7   
     7      8   namespace System.Data.SQLite
     8      9   {
     9     10     using System;
    10     11     using System.Collections.Generic;
    11         -  using System.Diagnostics;
    12         -  using System.Globalization;
    13         -  using System.IO;
    14         -  using System.Text;
    15     12     using System.Data;
    16         -  using System.Data.Common;
    17         -  using System.Data.Metadata.Edm;
    18     13     using System.Data.Common.CommandTrees;
    19         -  using System.Data.Common.Utils;
    20         -  using System.Data.Mapping.Update.Internal;
           14  +  using System.Data.Entity;
           15  +  using System.Runtime.CompilerServices;
    21     16   
    22         -  /// <summary>
    23         -  /// Class generating SQL for a DML command tree.
    24         -  /// </summary>
    25         -  internal static class DmlSqlGenerator
           17  +  internal class SqlChecker : DbExpressionVisitor<bool>
    26     18     {
    27         -    private static readonly int s_commandTextBuilderInitialCapacity = 256;
    28         -
    29         -    internal static string GenerateUpdateSql(DbUpdateCommandTree tree, out List<DbParameter> parameters)
    30         -    {
    31         -      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
    32         -      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, null != tree.Returning, "UpdateFunction");
    33         -
    34         -      // update [schemaName].[tableName]
    35         -      commandText.Append("UPDATE ");
    36         -      tree.Target.Expression.Accept(translator);
    37         -      commandText.AppendLine();
    38         -
    39         -      // set c1 = ..., c2 = ..., ...
    40         -      bool first = true;
    41         -      commandText.Append("SET ");
    42         -      foreach (DbSetClause setClause in tree.SetClauses)
    43         -      {
    44         -        if (first) { first = false; }
    45         -        else { commandText.Append(", "); }
    46         -        setClause.Property.Accept(translator);
    47         -        commandText.Append(" = ");
    48         -        setClause.Value.Accept(translator);
    49         -      }
    50         -
    51         -      if (first)
    52         -      {
    53         -        // If first is still true, it indicates there were no set
    54         -        // clauses. Introduce a fake set clause so that:
    55         -        // - we acquire the appropriate locks
    56         -        // - server-gen columns (e.g. timestamp) get recomputed
    57         -        //
    58         -        // We use the following pattern:
    59         -        //
    60         -        //  update Foo
    61         -        //  set @i = 0
    62         -        //  where ...
    63         -        DbParameter parameter = translator.CreateParameter(default(Int32), DbType.Int32);
    64         -        commandText.Append(parameter.ParameterName);
    65         -        commandText.Append(" = 0");
    66         -      }
    67         -      commandText.AppendLine();
    68         -
    69         -      // where c1 = ..., c2 = ...
    70         -      commandText.Append("WHERE ");
    71         -      tree.Predicate.Accept(translator);
    72         -      commandText.AppendLine();
    73         -
    74         -      // generate returning sql
    75         -      GenerateReturningSql(commandText, tree, translator, tree.Returning);
    76         -
    77         -      parameters = translator.Parameters;
    78         -      return commandText.ToString();
    79         -    }
    80         -
    81         -    internal static string GenerateDeleteSql(DbDeleteCommandTree tree, out List<DbParameter> parameters)
    82         -    {
    83         -      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
    84         -      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, false, "DeleteFunction");
    85         -
    86         -      // delete [schemaName].[tableName]
    87         -      commandText.Append("DELETE FROM ");
    88         -      tree.Target.Expression.Accept(translator);
    89         -      commandText.AppendLine();
    90         -
    91         -      // where c1 = ... AND c2 = ...
    92         -      commandText.Append("WHERE ");
    93         -      tree.Predicate.Accept(translator);
    94         -
    95         -      parameters = translator.Parameters;
    96         -
    97         -      commandText.AppendLine(";");
    98         -      return commandText.ToString();
    99         -    }
   100         -
   101         -    internal static string GenerateInsertSql(DbInsertCommandTree tree, out List<DbParameter> parameters)
   102         -    {
   103         -      StringBuilder commandText = new StringBuilder(s_commandTextBuilderInitialCapacity);
   104         -      ExpressionTranslator translator = new ExpressionTranslator(commandText, tree, null != tree.Returning, "InsertFunction");
   105         -
   106         -      // insert [schemaName].[tableName]
   107         -      commandText.Append("INSERT INTO ");
   108         -      tree.Target.Expression.Accept(translator);
   109         -
   110         -      if (tree.SetClauses.Count > 0)
   111         -      {
   112         -        // (c1, c2, c3, ...)
   113         -        commandText.Append("(");
   114         -        bool first = true;
   115         -        foreach (DbSetClause setClause in tree.SetClauses)
   116         -        {
   117         -          if (first) { first = false; }
   118         -          else { commandText.Append(", "); }
   119         -          setClause.Property.Accept(translator);
   120         -        }
   121         -        commandText.AppendLine(")");
   122         -
   123         -        // values c1, c2, ...
   124         -        first = true;
   125         -        commandText.Append(" VALUES (");
   126         -        foreach (DbSetClause setClause in tree.SetClauses)
   127         -        {
   128         -          if (first) { first = false; }
   129         -          else { commandText.Append(", "); }
   130         -          setClause.Value.Accept(translator);
   131         -
   132         -          translator.RegisterMemberValue(setClause.Property, setClause.Value);
   133         -        }
   134         -        commandText.AppendLine(");");
   135         -      }
   136         -      else // No columns specified.  Insert an empty row containing default values by inserting null into the rowid
   137         -      {
   138         -        commandText.AppendLine(" DEFAULT VALUES;");
   139         -      }
   140         -
   141         -      // generate returning sql
   142         -      GenerateReturningSql(commandText, tree, translator, tree.Returning);
   143         -
   144         -      parameters = translator.Parameters;
   145         -      return commandText.ToString();
   146         -    }
   147         -
   148         -    // Generates T-SQL describing a member
   149         -    // Requires: member must belong to an entity type (a safe requirement for DML
   150         -    // SQL gen, where we only access table columns)
   151         -    private static string GenerateMemberTSql(EdmMember member)
   152         -    {
   153         -      return SqlGenerator.QuoteIdentifier(member.Name);
           19  +    private static Type sql8rewriter;
           20  +
           21  +    static SqlChecker()
           22  +    {
           23  +      sql8rewriter = Type.GetType("System.Data.SqlClient.SqlGen.Sql8ExpressionRewriter, System.Data.Entity, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", false);
           24  +    }
           25  +
           26  +    private SqlChecker()
           27  +    {
   154     28       }
   155     29   
   156     30       /// <summary>
   157         -    /// Generates SQL fragment returning server-generated values.
   158         -    /// Requires: translator knows about member values so that we can figure out
   159         -    /// how to construct the key predicate.
   160         -    /// <code>
   161         -    /// Sample SQL:
   162         -    ///     
   163         -    ///     select IdentityValue
   164         -    ///     from dbo.MyTable
   165         -    ///     where @@ROWCOUNT > 0 and IdentityValue = scope_identity()
   166         -    /// 
   167         -    /// or
   168         -    /// 
   169         -    ///     select TimestamptValue
   170         -    ///     from dbo.MyTable
   171         -    ///     where @@ROWCOUNT > 0 and Id = 1
   172         -    /// 
   173         -    /// Note that we filter on rowcount to ensure no rows are returned if no rows were modified.
   174         -    /// </code>
   175         -    /// </summary>
   176         -    /// <param name="commandText">Builder containing command text</param>
   177         -    /// <param name="tree">Modification command tree</param>
   178         -    /// <param name="translator">Translator used to produce DML SQL statement
   179         -    /// for the tree</param>
   180         -    /// <param name="returning">Returning expression. If null, the method returns
   181         -    /// immediately without producing a SELECT statement.</param>
   182         -    private static void GenerateReturningSql(StringBuilder commandText, DbModificationCommandTree tree,
   183         -        ExpressionTranslator translator, DbExpression returning)
           31  +    /// SQLite doesn't support things like SKIP and a few other things.  So determine if the query has to be rewritten
           32  +    /// </summary>
           33  +    /// <remarks>
           34  +    /// Microsoft went to all the trouble of making things like SKIP work on Sql Server 2000 by doing a rewrite of the commandtree.
           35  +    /// However, all that fancy stuff is hidden from us.  Thanks to reflection however, we can go ahead and use the Sql 2000 rewriter code
           36  +    /// they made.
           37  +    /// </remarks>
           38  +    /// <param name="tree">The tree to inspect for a rewrite</param>
           39  +    /// <returns>Returns a new query tree if it needs rewriting</returns>
           40  +    internal static DbQueryCommandTree Rewrite(DbQueryCommandTree tree)
           41  +    {
           42  +      SqlChecker visitor = new SqlChecker();
           43  +      if (tree.Query.Accept<bool>(visitor))
           44  +      {
           45  +        tree = sql8rewriter.InvokeMember("Rewrite", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Static, null, null, new object[] { tree }) as DbQueryCommandTree;
           46  +      }      
           47  +      return tree;
           48  +    }
           49  +
           50  +    public override bool Visit(DbAndExpression expression)
           51  +    {
           52  +      return VisitBinaryExpression(expression);
           53  +    }
           54  +
           55  +    public override bool Visit(DbApplyExpression expression)
           56  +    {
           57  +      throw new NotSupportedException("apply expression");
           58  +    }
           59  +
           60  +    public override bool Visit(DbArithmeticExpression expression)
           61  +    {
           62  +      return VisitExpressionList(expression.Arguments);
           63  +    }
           64  +
           65  +    public override bool Visit(DbCaseExpression expression)
           66  +    {
           67  +      bool flag1 = VisitExpressionList(expression.When);
           68  +      bool flag2 = VisitExpressionList(expression.Then);
           69  +      bool flag3 = VisitExpression(expression.Else);
           70  +
           71  +      return (flag1 || flag2 || flag3);
           72  +    }
           73  +
           74  +    public override bool Visit(DbCastExpression expression)
           75  +    {
           76  +      return VisitUnaryExpression(expression);
           77  +    }
           78  +
           79  +    public override bool Visit(DbComparisonExpression expression)
           80  +    {
           81  +      return VisitBinaryExpression(expression);
           82  +    }
           83  +
           84  +    public override bool Visit(DbConstantExpression expression)
           85  +    {
           86  +      return false;
           87  +    }
           88  +
           89  +    public override bool Visit(DbCrossJoinExpression expression)
           90  +    {
           91  +      return VisitExpressionBindingList(expression.Inputs);
           92  +    }
           93  +
           94  +    public override bool Visit(DbDerefExpression expression)
           95  +    {
           96  +      return VisitUnaryExpression(expression);
           97  +    }
           98  +
           99  +    public override bool Visit(DbDistinctExpression expression)
          100  +    {
          101  +      return VisitUnaryExpression(expression);
          102  +    }
          103  +
          104  +    public override bool Visit(DbElementExpression expression)
          105  +    {
          106  +      return VisitUnaryExpression(expression);
          107  +    }
          108  +
          109  +    public override bool Visit(DbEntityRefExpression expression)
          110  +    {
          111  +      return VisitUnaryExpression(expression);
          112  +    }
          113  +
          114  +    public override bool Visit(DbExceptExpression expression)
          115  +    {
          116  +      bool flag1 = VisitExpression(expression.Left);
          117  +      bool flag2 = VisitExpression(expression.Right);
          118  +      return (flag1 || flag2);
          119  +    }
          120  +
          121  +    public override bool Visit(DbExpression expression)
          122  +    {
          123  +      throw new NotSupportedException(expression.GetType().FullName);
          124  +    }
          125  +
          126  +    public override bool Visit(DbFilterExpression expression)
          127  +    {
          128  +      bool flag1 = VisitExpressionBinding(expression.Input);
          129  +      bool flag2 = VisitExpression(expression.Predicate);
          130  +
          131  +      return (flag1 || flag2);
          132  +    }
          133  +
          134  +    public override bool Visit(DbFunctionExpression expression)
          135  +    {
          136  +      return VisitExpressionList(expression.Arguments);
          137  +    }
          138  +
          139  +    public override bool Visit(DbGroupByExpression expression)
          140  +    {
          141  +      bool flag1 = VisitExpression(expression.Input.Expression);
          142  +      bool flag2 = VisitExpressionList(expression.Keys);
          143  +      bool flag3 = VisitAggregateList(expression.Aggregates);
          144  +
          145  +      return (flag1 || flag2 || flag3);
          146  +    }
          147  +
          148  +    public override bool Visit(DbIntersectExpression expression)
          149  +    {
          150  +      bool flag1 = VisitExpression(expression.Left);
          151  +      bool flag2 = VisitExpression(expression.Right);
          152  +      return (flag1 || flag2);
          153  +    }
          154  +
          155  +    public override bool Visit(DbIsEmptyExpression expression)
          156  +    {
          157  +      return VisitUnaryExpression(expression);
          158  +    }
          159  +
          160  +    public override bool Visit(DbIsNullExpression expression)
          161  +    {
          162  +      return VisitUnaryExpression(expression);
          163  +    }
          164  +
          165  +    public override bool Visit(DbIsOfExpression expression)
          166  +    {
          167  +      return VisitUnaryExpression(expression);
          168  +    }
          169  +
          170  +    public override bool Visit(DbJoinExpression expression)
          171  +    {
          172  +      bool flag1 = VisitExpressionBinding(expression.Left);
          173  +      bool flag2 = VisitExpressionBinding(expression.Right);
          174  +      bool flag3 = VisitExpression(expression.JoinCondition);
          175  +      return (flag1 || flag2 || flag3);
          176  +    }
          177  +
          178  +    public override bool Visit(DbLikeExpression expression)
          179  +    {
          180  +      bool flag1 = VisitExpression(expression.Argument);
          181  +      bool flag2 = VisitExpression(expression.Pattern);
          182  +      bool flag3 = VisitExpression(expression.Escape);
          183  +      return (flag1 || flag2 || flag3);
          184  +    }
          185  +
          186  +    public override bool Visit(DbLimitExpression expression)
          187  +    {
          188  +      return VisitExpression(expression.Argument);
          189  +    }
          190  +
          191  +    public override bool Visit(DbNewInstanceExpression expression)
          192  +    {
          193  +      return VisitExpressionList(expression.Arguments);
          194  +    }
          195  +
          196  +    public override bool Visit(DbNotExpression expression)
          197  +    {
          198  +      return VisitUnaryExpression(expression);
          199  +    }
          200  +
          201  +    public override bool Visit(DbNullExpression expression)
          202  +    {
          203  +      return false;
          204  +    }
          205  +
          206  +    public override bool Visit(DbOfTypeExpression expression)
          207  +    {
          208  +      return VisitUnaryExpression(expression);
          209  +    }
          210  +
          211  +    public override bool Visit(DbOrExpression expression)
          212  +    {
          213  +      return VisitBinaryExpression(expression);
          214  +    }
          215  +
          216  +    public override bool Visit(DbParameterReferenceExpression expression)
          217  +    {
          218  +      return false;
          219  +    }
          220  +
          221  +    public override bool Visit(DbProjectExpression expression)
          222  +    {
          223  +      bool flag1 = VisitExpressionBinding(expression.Input);
          224  +      bool flag2 = VisitExpression(expression.Projection);
          225  +      return (flag1 || flag2);
          226  +    }
          227  +
          228  +    public override bool Visit(DbPropertyExpression expression)
          229  +    {
          230  +      return VisitExpression(expression.Instance);
          231  +    }
          232  +
          233  +    public override bool Visit(DbQuantifierExpression expression)
          234  +    {
          235  +      bool flag1 = VisitExpressionBinding(expression.Input);
          236  +      bool flag2 = VisitExpression(expression.Predicate);
          237  +      return (flag1 || flag2);
          238  +    }
          239  +
          240  +    public override bool Visit(DbRefExpression expression)
          241  +    {
          242  +      return VisitUnaryExpression(expression);
          243  +    }
          244  +
          245  +    public override bool Visit(DbRefKeyExpression expression)
          246  +    {
          247  +      return VisitUnaryExpression(expression);
          248  +    }
          249  +
          250  +    public override bool Visit(DbRelationshipNavigationExpression expression)
          251  +    {
          252  +      return VisitExpression(expression.NavigationSource);
          253  +    }
          254  +
          255  +    public override bool Visit(DbScanExpression expression)
          256  +    {
          257  +      return false;
          258  +    }
          259  +
          260  +    public override bool Visit(DbSkipExpression expression)
          261  +    {
          262  +      VisitExpressionBinding(expression.Input);
          263  +      VisitSortClauseList(expression.SortOrder);
          264  +      VisitExpression(expression.Count);
          265  +      return true;
          266  +    }
          267  +
          268  +    public override bool Visit(DbSortExpression expression)
          269  +    {
          270  +      bool flag1 = VisitExpressionBinding(expression.Input);
          271  +      bool flag2 = VisitSortClauseList(expression.SortOrder);
          272  +      return (flag1 || flag2);
          273  +    }
          274  +
          275  +    public override bool Visit(DbTreatExpression expression)
          276  +    {
          277  +      return VisitUnaryExpression(expression);
          278  +    }
          279  +
          280  +    public override bool Visit(DbUnionAllExpression expression)
          281  +    {
          282  +      return VisitBinaryExpression(expression);
          283  +    }
          284  +
          285  +    public override bool Visit(DbVariableReferenceExpression expression)
          286  +    {
          287  +      return false;
          288  +    }
          289  +
          290  +    private bool VisitAggregate(DbAggregate aggregate)
          291  +    {
          292  +      return VisitExpressionList(aggregate.Arguments);
          293  +    }
          294  +
          295  +    private bool VisitAggregateList(IList<DbAggregate> list)
          296  +    {
          297  +      return VisitList<DbAggregate>(new ListElementHandler<DbAggregate>(VisitAggregate), list);
          298  +    }
          299  +
          300  +    private bool VisitBinaryExpression(DbBinaryExpression expr)
          301  +    {
          302  +      bool flag1 = VisitExpression(expr.Left);
          303  +      bool flag2 = VisitExpression(expr.Right);
          304  +      return (flag1 || flag2);
          305  +    }
          306  +
          307  +    private bool VisitExpression(DbExpression expression)
          308  +    {
          309  +      if (expression == null)
          310  +      {
          311  +        return false;
          312  +      }
          313  +      return expression.Accept<bool>(this);
          314  +    }
          315  +
          316  +    private bool VisitExpressionBinding(DbExpressionBinding expressionBinding)
          317  +    {
          318  +      return VisitExpression(expressionBinding.Expression);
          319  +    }
          320  +
          321  +    private bool VisitExpressionBindingList(IList<DbExpressionBinding> list)
          322  +    {
          323  +      return VisitList<DbExpressionBinding>(new ListElementHandler<DbExpressionBinding>(VisitExpressionBinding), list);
          324  +    }
          325  +
          326  +    private bool VisitExpressionList(IList<DbExpression> list)
   184    327       {
   185         -      // Nothing to do if there is no Returning expression
   186         -      if (null == returning) { return; }
          328  +      return VisitList<DbExpression>(new ListElementHandler<DbExpression>(VisitExpression), list);
          329  +    }
   187    330   
   188         -      // select
   189         -      commandText.Append("SELECT ");
   190         -      returning.Accept(translator);
   191         -      commandText.AppendLine();
   192         -
   193         -      // from
   194         -      commandText.Append("FROM ");
   195         -      tree.Target.Expression.Accept(translator);
   196         -      commandText.AppendLine();
   197         -
   198         -      // where
   199         -      commandText.Append("WHERE last_rows_affected() > 0");
   200         -      EntitySetBase table = ((DbScanExpression)tree.Target.Expression).Target;
   201         -      bool identity = false;
   202         -      foreach (EdmMember keyMember in table.ElementType.KeyMembers)
          331  +    private static bool VisitList<TElementType>(ListElementHandler<TElementType> handler, IList<TElementType> list)
          332  +    {
          333  +      bool flag = false;
          334  +      foreach (TElementType local in list)
   203    335         {
   204         -        commandText.Append(" AND ");
   205         -        commandText.Append(GenerateMemberTSql(keyMember));
   206         -        commandText.Append(" = ");
          336  +        bool flag2 = handler(local);
          337  +        flag = flag || flag2;
          338  +      }
          339  +      return flag;
          340  +    }
          341  +
          342  +    private bool VisitSortClause(DbSortClause sortClause)
          343  +    {
          344  +      return VisitExpression(sortClause.Expression);
          345  +    }
          346  +
          347  +    private bool VisitSortClauseList(IList<DbSortClause> list)
          348  +    {
          349  +      return VisitList<DbSortClause>(new ListElementHandler<DbSortClause>(VisitSortClause), list);
          350  +    }
   207    351   
   208         -        // retrieve member value sql. the translator remembers member values
   209         -        // as it constructs the DML statement (which precedes the "returning"
   210         -        // SQL)
   211         -        DbParameter value;
   212         -        if (translator.MemberValues.TryGetValue(keyMember, out value))
   213         -        {
   214         -          commandText.Append(value.ParameterName);
   215         -        }
   216         -        else
   217         -        {
   218         -          // if no value is registered for the key member, it means it is an identity
   219         -          // which can be retrieved using the scope_identity() function
   220         -          if (identity)
   221         -          {
   222         -            // there can be only one server generated key
   223         -            throw new NotSupportedException(string.Format("Server generated keys are only supported for identity columns. More than one key column is marked as server generated in table '{0}'.", table.Name));
   224         -          }
   225         -          commandText.AppendLine("last_insert_rowid();");
   226         -          identity = true;
   227         -        }
   228         -      }
          352  +    private bool VisitUnaryExpression(DbUnaryExpression expr)
          353  +    {
          354  +      return VisitExpression(expr.Argument);
   229    355       }
   230    356   
   231         -    /// <summary>
   232         -    /// Lightweight expression translator for DML expression trees, which have constrained
   233         -    /// scope and support.
   234         -    /// </summary>
   235         -    private class ExpressionTranslator : DbExpressionVisitor
   236         -    {
   237         -      /// <summary>
   238         -      /// Initialize a new expression translator populating the given string builder
   239         -      /// with command text. Command text builder and command tree must not be null.
   240         -      /// </summary>
   241         -      /// <param name="commandText">Command text with which to populate commands</param>
   242         -      /// <param name="commandTree">Command tree generating SQL</param>
   243         -      /// <param name="preserveMemberValues">Indicates whether the translator should preserve
   244         -      /// member values while compiling t-SQL (only needed for server generation)</param>
   245         -      internal ExpressionTranslator(StringBuilder commandText, DbModificationCommandTree commandTree,
   246         -          bool preserveMemberValues, string kind)
   247         -      {
   248         -        Debug.Assert(null != commandText);
   249         -        Debug.Assert(null != commandTree);
   250         -        _kind = kind;
   251         -        _commandText = commandText;
   252         -        _commandTree = commandTree;
   253         -        _parameters = new List<DbParameter>();
   254         -        _memberValues = preserveMemberValues ? new Dictionary<EdmMember, DbParameter>() :
   255         -            null;
   256         -      }
   257         -
   258         -      private readonly StringBuilder _commandText;
   259         -      private readonly DbModificationCommandTree _commandTree;
   260         -      private readonly List<DbParameter> _parameters;
   261         -      private readonly Dictionary<EdmMember, DbParameter> _memberValues;
   262         -      private int parameterNameCount = 0;
   263         -      private string _kind;
   264         -
   265         -      internal List<DbParameter> Parameters { get { return _parameters; } }
   266         -      internal Dictionary<EdmMember, DbParameter> MemberValues { get { return _memberValues; } }
   267         -
   268         -      // generate parameter (name based on parameter ordinal)
   269         -      internal SQLiteParameter CreateParameter(object value, TypeUsage type)
   270         -      {
   271         -        PrimitiveTypeKind primitiveType = MetadataHelpers.GetPrimitiveTypeKind(type);
   272         -        DbType dbType = MetadataHelpers.GetDbType(primitiveType);
   273         -        return CreateParameter(value, dbType);
   274         -      }
   275         -
   276         -      // Creates a new parameter for a value in this expression translator
   277         -      internal SQLiteParameter CreateParameter(object value, DbType dbType)
   278         -      {
   279         -        string parameterName = string.Concat("@p", parameterNameCount.ToString(CultureInfo.InvariantCulture));
   280         -        parameterNameCount++;
   281         -        SQLiteParameter parameter = new SQLiteParameter(parameterName, value);
   282         -        parameter.DbType = dbType;
   283         -        _parameters.Add(parameter);
   284         -        return parameter;
   285         -      }
   286         -
   287         -      #region Basics
   288         -
   289         -      public override void Visit(DbApplyExpression expression)
   290         -      {
   291         -        if (expression == null) throw new ArgumentException("expression");
   292         -
   293         -        VisitExpressionBindingPre(expression.Input);
   294         -        if (expression.Apply != null)
   295         -        {
   296         -          VisitExpression(expression.Apply.Expression);
   297         -        }
   298         -        VisitExpressionBindingPost(expression.Input);
   299         -      }
   300         -
   301         -      public override void Visit(DbArithmeticExpression expression)
   302         -      {
   303         -        if (expression == null) throw new ArgumentException("expression");
   304         -        VisitExpressionList(expression.Arguments);
   305         -      }
   306         -
   307         -      public override void Visit(DbCaseExpression expression)
   308         -      {
   309         -        if (expression == null) throw new ArgumentException("expression");
   310         -        VisitExpressionList(expression.When);
   311         -        VisitExpressionList(expression.Then);
   312         -        VisitExpression(expression.Else);
   313         -      }
   314         -
   315         -      public override void Visit(DbCastExpression expression)
   316         -      {
   317         -        VisitUnaryExpression(expression);
   318         -      }
   319         -
   320         -      public override void Visit(DbCrossJoinExpression expression)
   321         -      {
   322         -        if (expression == null) throw new ArgumentException("expression");
   323         -        foreach (DbExpressionBinding binding in expression.Inputs)
   324         -        {
   325         -          VisitExpressionBindingPre(binding);
   326         -        }
   327         -        foreach (DbExpressionBinding binding2 in expression.Inputs)
   328         -        {
   329         -          VisitExpressionBindingPost(binding2);
   330         -        }
   331         -      }
   332         -
   333         -      public override void Visit(DbDerefExpression expression)
   334         -      {
   335         -        VisitUnaryExpression(expression);
   336         -      }
   337         -
   338         -      public override void Visit(DbDistinctExpression expression)
   339         -      {
   340         -        VisitUnaryExpression(expression);
   341         -      }
   342         -
   343         -      public override void Visit(DbElementExpression expression)
   344         -      {
   345         -        VisitUnaryExpression(expression);
   346         -      }
   347         -
   348         -      public override void Visit(DbEntityRefExpression expression)
   349         -      {
   350         -        VisitUnaryExpression(expression);
   351         -      }
   352         -
   353         -      public override void Visit(DbExceptExpression expression)
   354         -      {
   355         -        VisitBinary(expression);
   356         -      }
   357         -
   358         -      protected virtual void VisitBinary(DbBinaryExpression expression)
   359         -      {
   360         -        if (expression == null) throw new ArgumentException("expression");
   361         -        this.VisitExpression(expression.Left);
   362         -        this.VisitExpression(expression.Right);
   363         -      }
   364         -
   365         -      public override void Visit(DbExpression expression)
   366         -      {
   367         -        if (expression == null) throw new ArgumentException("expression");
   368         -        throw new NotSupportedException("DbExpression");
   369         -      }
   370         -
   371         -      public override void Visit(DbFilterExpression expression)
   372         -      {
   373         -        if (expression == null) throw new ArgumentException("expression");
   374         -        VisitExpressionBindingPre(expression.Input);
   375         -        VisitExpression(expression.Predicate);
   376         -        VisitExpressionBindingPost(expression.Input);
   377         -      }
   378         -
   379         -      public override void Visit(DbFunctionExpression expression)
   380         -      {
   381         -        if (expression == null) throw new ArgumentException("expression");
   382         -        VisitExpressionList(expression.Arguments);
   383         -        //if (expression.IsLambda)
   384         -        //{
   385         -        //  VisitLambdaFunctionPre(expression.Function, expression.LambdaBody);
   386         -        //  VisitExpression(expression.LambdaBody);
   387         -        //  VisitLambdaFunctionPost(expression.Function, expression.LambdaBody);
   388         -        //}
   389         -      }
   390         -
   391         -      public override void Visit(DbGroupByExpression expression)
   392         -      {
   393         -        if (expression == null) throw new ArgumentException("expression");
   394         -        VisitGroupExpressionBindingPre(expression.Input);
   395         -        VisitExpressionList(expression.Keys);
   396         -        VisitGroupExpressionBindingMid(expression.Input);
   397         -        VisitAggregateList(expression.Aggregates);
   398         -        VisitGroupExpressionBindingPost(expression.Input);
   399         -      }
   400         -
   401         -      public override void Visit(DbIntersectExpression expression)
   402         -      {
   403         -        VisitBinary(expression);
   404         -      }
   405         -
   406         -      public override void Visit(DbIsEmptyExpression expression)
   407         -      {
   408         -        VisitUnaryExpression(expression);
   409         -      }
   410         -
   411         -      public override void Visit(DbIsOfExpression expression)
   412         -      {
   413         -        VisitUnaryExpression(expression);
   414         -      }
   415         -
   416         -      public override void Visit(DbJoinExpression expression)
   417         -      {
   418         -        if (expression == null) throw new ArgumentException("expression");
   419         -        VisitExpressionBindingPre(expression.Left);
   420         -        VisitExpressionBindingPre(expression.Right);
   421         -        VisitExpression(expression.JoinCondition);
   422         -        VisitExpressionBindingPost(expression.Left);
   423         -        VisitExpressionBindingPost(expression.Right);
   424         -      }
   425         -
   426         -      public override void Visit(DbLikeExpression expression)
   427         -      {
   428         -        if (expression == null) throw new ArgumentException("expression");
   429         -        VisitExpression(expression.Argument);
   430         -        VisitExpression(expression.Pattern);
   431         -        VisitExpression(expression.Escape);
   432         -      }
   433         -
   434         -      public override void Visit(DbLimitExpression expression)
   435         -      {
   436         -        if (expression == null) throw new ArgumentException("expression");
   437         -        VisitExpression(expression.Argument);
   438         -        VisitExpression(expression.Limit);
   439         -      }
   440         -
   441         -      public override void Visit(DbOfTypeExpression expression)
   442         -      {
   443         -        VisitUnaryExpression(expression);
   444         -      }
   445         -
   446         -      public override void Visit(DbParameterReferenceExpression expression)
   447         -      {
   448         -        if (expression == null) throw new ArgumentException("expression");
   449         -      }
   450         -
   451         -      public override void Visit(DbProjectExpression expression)
   452         -      {
   453         -        if (expression == null) throw new ArgumentException("expression");
   454         -        VisitExpressionBindingPre(expression.Input);
   455         -        VisitExpression(expression.Projection);
   456         -        VisitExpressionBindingPost(expression.Input);
   457         -      }
   458         -
   459         -      public override void Visit(DbQuantifierExpression expression)
   460         -      {
   461         -        if (expression == null) throw new ArgumentException("expression");
   462         -        VisitExpressionBindingPre(expression.Input);
   463         -        VisitExpression(expression.Predicate);
   464         -        VisitExpressionBindingPost(expression.Input);
   465         -      }
   466         -
   467         -      public override void Visit(DbRefExpression expression)
   468         -      {
   469         -        VisitUnaryExpression(expression);
   470         -      }
   471         -
   472         -      public override void Visit(DbRefKeyExpression expression)
   473         -      {
   474         -        VisitUnaryExpression(expression);
   475         -      }
   476         -
   477         -      public override void Visit(DbRelationshipNavigationExpression expression)
   478         -      {
   479         -        if (expression == null) throw new ArgumentException("expression");
   480         -        VisitExpression(expression.NavigationSource);
   481         -      }
   482         -
   483         -      public override void Visit(DbSkipExpression expression)
   484         -      {
   485         -        if (expression == null) throw new ArgumentException("expression");
   486         -        VisitExpressionBindingPre(expression.Input);
   487         -        foreach (DbSortClause clause in expression.SortOrder)
   488         -        {
   489         -          VisitExpression(clause.Expression);
   490         -        }
   491         -        VisitExpressionBindingPost(expression.Input);
   492         -        VisitExpression(expression.Count);
   493         -      }
   494         -
   495         -      public override void Visit(DbSortExpression expression)
   496         -      {
   497         -        if (expression == null) throw new ArgumentException("expression");
   498         -        VisitExpressionBindingPre(expression.Input);
   499         -        for (int i = 0; i < expression.SortOrder.Count; i++)
   500         -        {
   501         -          VisitExpression(expression.SortOrder[i].Expression);
   502         -        }
   503         -        VisitExpressionBindingPost(expression.Input);
   504         -      }
   505         -
   506         -      public override void Visit(DbTreatExpression expression)
   507         -      {
   508         -        VisitUnaryExpression(expression);
   509         -      }
   510         -
   511         -      public override void Visit(DbUnionAllExpression expression)
   512         -      {
   513         -        VisitBinary(expression);
   514         -      }
   515         -
   516         -      public override void Visit(DbVariableReferenceExpression expression)
   517         -      {
   518         -        if (expression == null) throw new ArgumentException("expression");
   519         -      }
   520         -
   521         -      public virtual void VisitAggregate(DbAggregate aggregate)
   522         -      {
   523         -        if (aggregate == null) throw new ArgumentException("aggregate");
   524         -        VisitExpressionList(aggregate.Arguments);
   525         -      }
   526         -
   527         -      public virtual void VisitAggregateList(IList<DbAggregate> aggregates)
   528         -      {
   529         -        if (aggregates == null) throw new ArgumentException("aggregates");
   530         -        for (int i = 0; i < aggregates.Count; i++)
   531         -        {
   532         -          VisitAggregate(aggregates[i]);
   533         -        }
   534         -      }
   535         -
   536         -      public virtual void VisitExpression(DbExpression expression)
   537         -      {
   538         -        if (expression == null) throw new ArgumentException("expression");
   539         -        expression.Accept(this);
   540         -      }
   541         -
   542         -      protected virtual void VisitExpressionBindingPost(DbExpressionBinding binding)
   543         -      {
   544         -      }
   545         -
   546         -      protected virtual void VisitExpressionBindingPre(DbExpressionBinding binding)
   547         -      {
   548         -        if (binding == null) throw new ArgumentException("binding");
   549         -        VisitExpression(binding.Expression);
   550         -      }
   551         -
   552         -      public virtual void VisitExpressionList(IList<DbExpression> expressionList)
   553         -      {
   554         -        if (expressionList == null) throw new ArgumentException("expressionList");
   555         -        for (int i = 0; i < expressionList.Count; i++)
   556         -        {
   557         -          VisitExpression(expressionList[i]);
   558         -        }
   559         -      }
   560         -
   561         -      protected virtual void VisitGroupExpressionBindingMid(DbGroupExpressionBinding binding)
   562         -      {
   563         -      }
   564         -
   565         -      protected virtual void VisitGroupExpressionBindingPost(DbGroupExpressionBinding binding)
   566         -      {
   567         -      }
   568         -
   569         -      protected virtual void VisitGroupExpressionBindingPre(DbGroupExpressionBinding binding)
   570         -      {
   571         -        if (binding == null) throw new ArgumentException("binding");
   572         -        VisitExpression(binding.Expression);
   573         -      }
   574         -
   575         -      protected virtual void VisitLambdaFunctionPost(EdmFunction function, DbExpression body)
   576         -      {
   577         -      }
   578         -
   579         -      protected virtual void VisitLambdaFunctionPre(EdmFunction function, DbExpression body)
   580         -      {
   581         -        if (function == null) throw new ArgumentException("function");
   582         -        if (body == null) throw new ArgumentException("body");
   583         -      }
   584         -
   585         -      //internal virtual void VisitRelatedEntityReference(DbRelatedEntityRef relatedEntityRef)
   586         -      //{
   587         -      //  VisitExpression(relatedEntityRef.TargetEntityReference);
   588         -      //}
   589         -
   590         -      //internal virtual void VisitRelatedEntityReferenceList(IList<DbRelatedEntityRef> relatedEntityReferences)
   591         -      //{
   592         -      //  for (int i = 0; i < relatedEntityReferences.Count; i++)
   593         -      //  {
   594         -      //    VisitRelatedEntityReference(relatedEntityReferences[i]);
   595         -      //  }
   596         -      //}
   597         -
   598         -      protected virtual void VisitUnaryExpression(DbUnaryExpression expression)
   599         -      {
   600         -        if (expression == null) throw new ArgumentException("expression");
   601         -        VisitExpression(expression.Argument);
   602         -      }
   603         -      #endregion
   604         -
   605         -      public override void Visit(DbAndExpression expression)
   606         -      {
   607         -        VisitBinary(expression, " AND ");
   608         -      }
   609         -
   610         -      public override void Visit(DbOrExpression expression)
   611         -      {
   612         -        VisitBinary(expression, " OR ");
   613         -      }
   614         -
   615         -      public override void Visit(DbComparisonExpression expression)
   616         -      {
   617         -        Debug.Assert(expression.ExpressionKind == DbExpressionKind.Equals,
   618         -            "only equals comparison expressions are produced in DML command trees in V1");
   619         -
   620         -        VisitBinary(expression, " = ");
   621         -
   622         -        RegisterMemberValue(expression.Left, expression.Right);
   623         -      }
   624         -
   625         -      /// <summary>
   626         -      /// Call this method to register a property value pair so the translator "remembers"
   627         -      /// the values for members of the row being modified. These values can then be used
   628         -      /// to form a predicate for server-generation (based on the key of the row)
   629         -      /// </summary>
   630         -      /// <param name="propertyExpression">DbExpression containing the column reference (property expression).</param>
   631         -      /// <param name="value">DbExpression containing the value of the column.</param>
   632         -      internal void RegisterMemberValue(DbExpression propertyExpression, DbExpression value)
   633         -      {
   634         -        if (null != _memberValues)
   635         -        {
   636         -          // register the value for this property
   637         -          Debug.Assert(propertyExpression.ExpressionKind == DbExpressionKind.Property,
   638         -              "DML predicates and setters must be of the form property = value");
   639         -
   640         -          // get name of left property 
   641         -          EdmMember property = ((DbPropertyExpression)propertyExpression).Property;
   642         -
   643         -          // don't track null values
   644         -          if (value.ExpressionKind != DbExpressionKind.Null)
   645         -          {
   646         -            Debug.Assert(value.ExpressionKind == DbExpressionKind.Constant,
   647         -                "value must either constant or null");
   648         -            // retrieve the last parameter added (which describes the parameter)
   649         -            _memberValues[property] = _parameters[_parameters.Count - 1];
   650         -          }
   651         -        }
   652         -      }
   653         -
   654         -      public override void Visit(DbIsNullExpression expression)
   655         -      {
   656         -        expression.Argument.Accept(this);
   657         -        _commandText.Append(" IS NULL");
   658         -      }
   659         -
   660         -      public override void Visit(DbNotExpression expression)
   661         -      {
   662         -        _commandText.Append("NOT (");
   663         -        expression.Accept(this);
   664         -        _commandText.Append(")");
   665         -      }
   666         -
   667         -      public override void Visit(DbConstantExpression expression)
   668         -      {
   669         -        SQLiteParameter parameter = CreateParameter(expression.Value, expression.ResultType);
   670         -        _commandText.Append(parameter.ParameterName);
   671         -      }
   672         -
   673         -      public override void Visit(DbScanExpression expression)
   674         -      {
   675         -        string definingQuery = MetadataHelpers.TryGetValueForMetadataProperty<string>(expression.Target, "DefiningQuery");
   676         -        if (definingQuery != null)
   677         -        {
   678         -          throw new NotSupportedException(String.Format("Unable to update the EntitySet '{0}' because it has a DefiningQuery and no <{1}> element exists in the <ModificationFunctionMapping> element to support the current operation.", expression.Target.Name, _kind));
   679         -        }
   680         -        _commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
   681         -      }
   682         -
   683         -      public override void Visit(DbPropertyExpression expression)
   684         -      {
   685         -        _commandText.Append(GenerateMemberTSql(expression.Property));
   686         -      }
   687         -
   688         -      public override void Visit(DbNullExpression expression)
   689         -      {
   690         -        _commandText.Append("NULL");
   691         -      }
   692         -
   693         -      public override void Visit(DbNewInstanceExpression expression)
   694         -      {
   695         -        // assumes all arguments are self-describing (no need to use aliases
   696         -        // because no renames are ever used in the projection)
   697         -        bool first = true;
   698         -        foreach (DbExpression argument in expression.Arguments)
   699         -        {
   700         -          if (first) { first = false; }
   701         -          else { _commandText.Append(", "); }
   702         -          argument.Accept(this);
   703         -        }
   704         -      }
   705         -
   706         -      private void VisitBinary(DbBinaryExpression expression, string separator)
   707         -      {
   708         -        _commandText.Append("(");
   709         -        expression.Left.Accept(this);
   710         -        _commandText.Append(separator);
   711         -        expression.Right.Accept(this);
   712         -        _commandText.Append(")");
   713         -      }
   714         -    }
          357  +    private delegate bool ListElementHandler<TElementType>(TElementType element);
   715    358     }
   716    359   }
   717         -

Changes to System.Data.SQLite.Linq/System.Data.SQLite.Linq.csproj.

    21     21       <DebugType>full</DebugType>
    22     22       <Optimize>false</Optimize>
    23     23       <OutputPath>..\bin\</OutputPath>
    24     24       <DefineConstants>DEBUG;TRACE</DefineConstants>
    25     25       <ErrorReport>prompt</ErrorReport>
    26     26       <WarningLevel>4</WarningLevel>
    27     27       <PlatformTarget>AnyCPU</PlatformTarget>
           28  +    <UseVSHostingProcess>false</UseVSHostingProcess>
    28     29     </PropertyGroup>
    29     30     <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    30     31       <DebugType>none</DebugType>
    31     32       <Optimize>true</Optimize>
    32     33       <OutputPath>..\bin\</OutputPath>
    33     34       <DefineConstants>TRACE</DefineConstants>
    34     35       <ErrorReport>prompt</ErrorReport>
    35     36       <WarningLevel>4</WarningLevel>
    36     37       <PlatformTarget>AnyCPU</PlatformTarget>
           38  +    <UseVSHostingProcess>false</UseVSHostingProcess>
    37     39     </PropertyGroup>
    38     40     <ItemGroup>
    39     41       <Reference Include="System" />
    40     42       <Reference Include="System.Core">
    41     43         <RequiredTargetFramework>3.5</RequiredTargetFramework>
    42     44       </Reference>
    43     45       <Reference Include="System.Data" />

Changes to System.Data.SQLite/AssemblyInfo.cs.

     1      1   using System;
     2      2   using System.Reflection;
     3      3   using System.Runtime.CompilerServices;
     4      4   using System.Runtime.InteropServices;
     5      5   using System.Security.Permissions;
     6      6   using System.Security;
            7  +using System.Resources;
     7      8   
     8      9   #if !PLATFORM_COMPACTFRAMEWORK
     9     10   using System.Runtime.ConstrainedExecution;
    10     11   #endif
    11     12   
    12     13   // General Information about an assembly is controlled through the following 
    13     14   // set of attributes. Change these attribute values to modify the information
................................................................................
    27     28   
    28     29   //  Setting ComVisible to false makes the types in this assembly not visible 
    29     30   //  to COM componenets.  If you need to access a type in this assembly from 
    30     31   //  COM, set the ComVisible attribute to true on that type.
    31     32   [assembly: ComVisible(false)]
    32     33   [assembly: CLSCompliant(true)]
    33     34   [assembly: InternalsVisibleTo("System.Data.SQLite.Linq, PublicKey=002400000480000094000000060200000024000052534131000400000100010005a288de5687c4e1b621ddff5d844727418956997f475eb829429e411aff3e93f97b70de698b972640925bdd44280df0a25a843266973704137cbb0e7441c1fe7cae4e2440ae91ab8cde3933febcb1ac48dd33b40e13c421d8215c18a4349a436dd499e3c385cc683015f886f6c10bd90115eb2bd61b67750839e3a19941dc9c")]
           35  +[assembly: NeutralResourcesLanguage("en")]
    34     36   
    35     37   #if !PLATFORM_COMPACTFRAMEWORK
    36     38   [assembly: AllowPartiallyTrustedCallers]
    37     39   [assembly: ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    38     40   [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
    39     41   #endif
    40     42   
................................................................................
    43     45   //      Major Version
    44     46   //      Minor Version 
    45     47   //      Build Number
    46     48   //      Revision
    47     49   //
    48     50   // You can specify all the values or you can default the Revision and Build Numbers 
    49     51   // by using the '*' as shown below:
    50         -[assembly: AssemblyVersion("1.0.64.0")]
           52  +[assembly: AssemblyVersion("1.0.66.0")]
    51     53   #if !PLATFORM_COMPACTFRAMEWORK
    52         -[assembly: AssemblyFileVersion("1.0.64.0")]
           54  +[assembly: AssemblyFileVersion("1.0.66.0")]
    53     55   #endif

Changes to System.Data.SQLite/SQLite3.cs.

    19     19     {
    20     20       /// <summary>
    21     21       /// The opaque pointer returned to us by the sqlite provider
    22     22       /// </summary>
    23     23       protected SQLiteConnectionHandle _sql;
    24     24       protected string _fileName;
    25     25       protected bool _usePool;
    26         -    protected int _poolVersion = 0;
           26  +    protected int _poolVersion;
    27     27   
    28     28   #if !PLATFORM_COMPACTFRAMEWORK
    29         -    private bool _buildingSchema = false;
           29  +    private bool _buildingSchema;
    30     30   #endif
    31     31       /// <summary>
    32     32       /// The user-defined functions registered on this connection
    33     33       /// </summary>
    34     34       protected SQLiteFunction[] _functionsArray;
    35     35   
    36     36       internal SQLite3(SQLiteDateFormats fmt)
................................................................................
   472    472   
   473    473       internal override int ColumnIndex(SQLiteStatement stmt, string columnName)
   474    474       {
   475    475         int x = ColumnCount(stmt);
   476    476   
   477    477         for (int n = 0; n < x; n++)
   478    478         {
   479         -        if (String.Compare(columnName, ColumnName(stmt, n), true, CultureInfo.InvariantCulture) == 0)
          479  +        if (String.Compare(columnName, ColumnName(stmt, n), StringComparison.OrdinalIgnoreCase) == 0)
   480    480             return n;
   481    481         }
   482    482         return -1;
   483    483       }
   484    484   
   485    485       internal override string ColumnOriginalName(SQLiteStatement stmt, int index)
   486    486       {
................................................................................
   652    652   #endif
   653    653         if (n > 0) throw new SQLiteException(n, SQLiteLastError());
   654    654       }
   655    655   
   656    656       internal override void CreateCollation(string strCollation, SQLiteCollation func, SQLiteCollation func16)
   657    657       {
   658    658         int n = UnsafeNativeMethods.sqlite3_create_collation(_sql, ToUTF8(strCollation), 2, IntPtr.Zero, func16);
   659         -      if (n == 0) UnsafeNativeMethods.sqlite3_create_collation(_sql, ToUTF8(strCollation), 1, IntPtr.Zero, func);
          659  +      if (n == 0) n = UnsafeNativeMethods.sqlite3_create_collation(_sql, ToUTF8(strCollation), 1, IntPtr.Zero, func);
   660    660         if (n > 0) throw new SQLiteException(n, SQLiteLastError());
   661    661       }
   662    662   
   663    663       internal override int ContextCollateCompare(CollationEncodingEnum enc, IntPtr context, string s1, string s2)
   664    664       {
   665    665   #if !SQLITE_STANDARD
   666    666         byte[] b1;

Changes to System.Data.SQLite/SQLiteBase.cs.

   170    170       protected virtual void Dispose(bool bDisposing)
   171    171       {
   172    172       }
   173    173   
   174    174       public void Dispose()
   175    175       {
   176    176         Dispose(true);
          177  +      GC.SuppressFinalize(this);
   177    178       }
   178    179   
   179    180       // These statics are here for lack of a better place to put them.
   180    181       // They exist here because they are called during the finalization of
   181    182       // a SQLiteStatementHandle, SQLiteConnectionHandle, and SQLiteFunctionCookieHandle.
   182    183       // Therefore these functions have to be static, and have to be low-level.
   183    184   
................................................................................
   219    220       }
   220    221   
   221    222       internal static void ResetConnection(SQLiteConnectionHandle db)
   222    223       {
   223    224         lock (_lock)
   224    225         {
   225    226           IntPtr stmt = IntPtr.Zero;
   226         -
          227  +        int n;
   227    228           do
   228    229           {
   229    230             stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
   230    231             if (stmt != IntPtr.Zero)
   231    232             {
   232    233   #if !SQLITE_STANDARD
   233         -            UnsafeNativeMethods.sqlite3_reset_interop(stmt);
          234  +            n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
   234    235   #else
   235         -          UnsafeNativeMethods.sqlite3_reset(stmt);
          236  +            n = UnsafeNativeMethods.sqlite3_reset(stmt);
   236    237   #endif
   237    238             }
   238    239           } while (stmt != IntPtr.Zero);
   239    240   
   240    241           if (IsAutocommit(db) == false) // a transaction is pending on the connection
   241    242           {
   242         -          // Not really concerned with the return value from a rollback.
   243         -          UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
          243  +          n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
          244  +          if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
   244    245           }
   245    246         }
   246    247       }
   247    248   
   248    249       internal static bool IsAutocommit(SQLiteConnectionHandle hdl)
   249    250       {
   250    251         return (UnsafeNativeMethods.sqlite3_get_autocommit(hdl) == 1);

Changes to System.Data.SQLite/SQLiteCommand.cs.

    13     13     using System.Collections.Generic;
    14     14     using System.ComponentModel;
    15     15   
    16     16     /// <summary>
    17     17     /// SQLite implementation of DbCommand.
    18     18     /// </summary>
    19     19   #if !PLATFORM_COMPACTFRAMEWORK
    20         -  [Designer("SQLite.Designer.SQLiteCommandDesigner, SQLite.Designer, Version=1.0.36.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139"), ToolboxItem(true)]
           20  +  [Designer("SQLite.Designer.SQLiteCommandDesigner, SQLite.Designer, Version=1.0.37.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139"), ToolboxItem(true)]
    21     21   #endif
    22     22     public sealed class SQLiteCommand : DbCommand, ICloneable
    23     23     {
    24     24       /// <summary>
    25     25       /// The command text this command is based on
    26     26       /// </summary>
    27     27       private string _commandText;
................................................................................
   121    121       /// Initializes a command with the given SQL, connection and transaction
   122    122       /// </summary>
   123    123       /// <param name="commandText">The SQL command text</param>
   124    124       /// <param name="connection">The connection to associate with the command</param>
   125    125       /// <param name="transaction">The transaction the command should be associated with</param>
   126    126       public SQLiteCommand(string commandText, SQLiteConnection connection, SQLiteTransaction transaction)
   127    127       {
   128         -      _statementList = null;
   129         -      _activeReader = null;
   130    128         _commandTimeout = 30;
   131    129         _parameterCollection = new SQLiteParameterCollection(this);
   132    130         _designTimeVisible = true;
   133    131         _updateRowSource = UpdateRowSource.None;
   134         -      _transaction = null;
   135    132   
   136    133         if (commandText != null)
   137    134           CommandText = commandText;
   138    135   
   139    136         if (connection != null)
   140    137         {
   141    138           DbConnection = connection;
................................................................................
   160    157           SQLiteDataReader reader = null;
   161    158           if (_activeReader != null)
   162    159           {
   163    160             try
   164    161             {
   165    162               reader = _activeReader.Target as SQLiteDataReader;
   166    163             }
   167         -          catch
          164  +          catch(InvalidOperationException)
   168    165             {
   169    166             }
   170    167           }
   171    168   
   172    169           if (reader != null)
   173    170           {
   174    171             reader._disposeCommand = true;
................................................................................
   190    187         if (_activeReader != null)
   191    188         {
   192    189           SQLiteDataReader reader = null;
   193    190           try
   194    191           {
   195    192             reader = _activeReader.Target as SQLiteDataReader;
   196    193           }
   197         -        catch
          194  +        catch(InvalidOperationException)
   198    195           {
   199    196           }
   200    197   
   201    198           if (reader != null)
   202    199             reader.Close();
   203    200   
   204    201           _activeReader = null;

Changes to System.Data.SQLite/SQLiteCommandBuilder.cs.

   263    263       public override string UnquoteIdentifier(string quotedIdentifier)
   264    264       {
   265    265         if (String.IsNullOrEmpty(QuotePrefix)
   266    266           || String.IsNullOrEmpty(QuoteSuffix)
   267    267           || String.IsNullOrEmpty(quotedIdentifier))
   268    268           return quotedIdentifier;
   269    269   
   270         -      if (quotedIdentifier.StartsWith(QuotePrefix, StringComparison.InvariantCultureIgnoreCase) == false
   271         -        || quotedIdentifier.EndsWith(QuoteSuffix, StringComparison.InvariantCultureIgnoreCase) == false)
          270  +      if (quotedIdentifier.StartsWith(QuotePrefix, StringComparison.OrdinalIgnoreCase) == false
          271  +        || quotedIdentifier.EndsWith(QuoteSuffix, StringComparison.OrdinalIgnoreCase) == false)
   272    272           return quotedIdentifier;
   273    273   
   274    274         return quotedIdentifier.Substring(QuotePrefix.Length, quotedIdentifier.Length - (QuotePrefix.Length + QuoteSuffix.Length)).Replace(QuoteSuffix + QuoteSuffix, QuoteSuffix);
   275    275       }
   276    276   
   277    277       /// <summary>
   278    278       /// Overridden to hide its property from the designer

Changes to System.Data.SQLite/SQLiteConnection.cs.

   223    223   
   224    224       /// <summary>
   225    225       /// Initializes the connection with the specified connection string
   226    226       /// </summary>
   227    227       /// <param name="connectionString">The connection string to use on the connection</param>
   228    228       public SQLiteConnection(string connectionString)
   229    229       {
   230         -      _sql = null;
   231    230         _connectionState = ConnectionState.Closed;
   232    231         _connectionString = "";
   233         -      _transactionLevel = 0;
   234         -      _version = 0;
   235    232         //_commandList = new List<WeakReference>();
   236    233   
   237    234         if (connectionString != null)
   238    235           ConnectionString = connectionString;
   239    236       }
   240    237   
   241    238       /// <summary>
................................................................................
   255    252   
   256    253           // Reattach all attached databases from the existing connection
   257    254           using (DataTable tbl = connection.GetSchema("Catalogs"))
   258    255           {
   259    256             foreach (DataRow row in tbl.Rows)
   260    257             {
   261    258               str = row[0].ToString();
   262         -            if (String.Compare(str, "main", true, CultureInfo.InvariantCulture) != 0
   263         -              && String.Compare(str, "temp", true, CultureInfo.InvariantCulture) != 0)
          259  +            if (String.Compare(str, "main", StringComparison.OrdinalIgnoreCase) != 0
          260  +              && String.Compare(str, "temp", StringComparison.OrdinalIgnoreCase) != 0)
   264    261               {
   265    262                 using (SQLiteCommand cmd = CreateCommand())
   266    263                 {
   267    264                   cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "ATTACH DATABASE '{0}' AS [{1}]", row[1], row[0]);
   268    265                   cmd.ExecuteNonQuery();
   269    266                 }
   270    267               }
................................................................................
   597    594       /// <description>N</description>
   598    595       /// <description>Serializable</description>
   599    596       /// </item>
   600    597       /// </list>
   601    598       /// </remarks>
   602    599   #if !PLATFORM_COMPACTFRAMEWORK
   603    600       [RefreshProperties(RefreshProperties.All), DefaultValue("")]
   604         -    [Editor("SQLite.Designer.SQLiteConnectionStringEditor, SQLite.Designer, Version=1.0.36.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
          601  +    [Editor("SQLite.Designer.SQLiteConnectionStringEditor, SQLite.Designer, Version=1.0.37.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]