Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Comment: | 1.0.52.0 |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | sourceforge |
Files: | files | file ages | folders |
SHA1: |
1084c9879015380788732bfea328ecb7 |
User & Date: | rmsimpson 2008-07-16 23:32:23 |
2008-07-24
| ||
06:19 | 1.0.53.0 check-in: 2b553f96c4 user: rmsimpson tags: sourceforge | |
2008-07-16
| ||
23:32 | 1.0.52.0 check-in: 1084c98790 user: rmsimpson tags: sourceforge | |
23:32 | no message check-in: c49238f784 user: rmsimpson tags: sourceforge | |
Changes to Doc/Extra/dbfactorysupport.html.
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
<configuration>
<system.data>
<DbProviderFactories>
<remove invariant="System.Data.SQLite"/>
<add name="SQLite Data Provider" invariant="System.Data.SQLite"
description=".Net Framework Data Provider for SQLite"
type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite,
Version=1.0.50.0, Culture=neutral,
PublicKeyToken=db937bc2d44ff139"/>
</DbProviderFactories>
</system.data>
</configuration>
</pre>
</div>
<p>
|
| |
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
<configuration>
<system.data>
<DbProviderFactories>
<remove invariant="System.Data.SQLite"/>
<add name="SQLite Data Provider" invariant="System.Data.SQLite"
description=".Net Framework Data Provider for SQLite"
type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite,
Version=1.0.52.0, Culture=neutral,
PublicKeyToken=db937bc2d44ff139"/>
</DbProviderFactories>
</system.data>
</configuration>
</pre>
</div>
<p>
|
Changes to Doc/Extra/version.html.
51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
</td> </tr> </table> </div> <div id="mainSection"> <div id="mainBody"> <h1 class="heading">Version History</h1> <p><b>1.0.50.0 - June 27, 2008</b></p> <ul> <li>Fixed some lingering dispose issues and race conditions when some objects were finalized.</li> <li>Fixed the SQLiteConvert.Split() routine to be a little smarter when splitting strings, which solves the quoted data source filename problem.</li> <li>Enhanced the mergebin utility to work around the strong name validation bug on the Compact Framework. The old workaround kludged the DLL and caused WM6.1 |
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
</td> </tr> </table> </div> <div id="mainSection"> <div id="mainBody"> <h1 class="heading">Version History</h1> <p><b>1.0.52.0 - July 16, 2008</b></p> <ul> <li>Code merge with SQLite 3.6.0</li> <li>Added a lot of previously-missing exports to the DEF file for the native library.</li> <li>Fixed SQLiteDataReader to check for an invalid connection before operating on an open cursor.</li> <li>Implemented the Cancel() function of SQLiteCommand to cancel an active reader.</li> <li>Added beta table and view designers to the Visual Studio Server Explorer. You can now edit/create tables and views, manage indexes and foreign keys from Visual Studio. This feature is still undergoing testing so use at your own risk!</li> <li>Fixed the Server Explorer so VS2005 users can once again right-click tables and views and open the table data.</li> <li>Added some new interop code to assist in returning more metadata not normally available through the SQLite API. Specifically, index column sort modes and collating sequences. Also added code to detect (but not parse) CHECK constraints, so the table designer can pop up a warning when editing a table with these constraints. Since I can't currently parse them.</li> <li>Lots of LINQ SQL generation improvements and fixes.</li> <li>Made some progress cleaning up and fixing up the schema definitions and manifests for EdmGen.</li> <li>Added a built-in SQLiteFunction called last_rows_affected() which can be called from SQL to get the number of rows affected by the last update/insert operation on the connection. This is roughly equivalent to Sql Server's @@ROWCOUNT variable.</li> </ul> <p><b>1.0.51.0 - July 1, 2008</b></p> <ul> <li><b>VS2008 SP1 Beta1 LINQ Support</b></li> <li>Added experimental Entity Framework support in a new library, System.Data.SQLite.Linq. Some things work, some don't. I haven't finished rigging everything up yet. The core library remains stable. All LINQ-specific code is completely separate from the core.</li> <li> Added some columns to several existing schemas to support some of the EDM framework stuff.</li> <li>Minor tweaks to the factory to better support dynamic loading of the Linq extension library for SQLite.</li> <li>SQLite's busy handler was interfering with the provider's busy handling mechanism, so its been disabled.</li> </ul> <p><b>1.0.50.0 - June 27, 2008</b></p> <ul> <li>Fixed some lingering dispose issues and race conditions when some objects were finalized.</li> <li>Fixed the SQLiteConvert.Split() routine to be a little smarter when splitting strings, which solves the quoted data source filename problem.</li> <li>Enhanced the mergebin utility to work around the strong name validation bug on the Compact Framework. The old workaround kludged the DLL and caused WM6.1 |
Changes to Doc/Extra/welcome.html.
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
<br> </DIV> <h1 class="heading">What's Coming Up?</h1> <p>There's a few things I'm aiming to do in the near future: </p> <DIV> <ul> <LI> More class documentation and examples. I'll also be integrating a lot of the documentation from the official <A target="_blank" href="http://www.sqlite.org"> sqlite.org</A> website into the helpfile for quick and easy access.</LI> <li>Design-time support for DDL, enabling you to create/alter tables, manage indexes and foreign keys, etc.</li> </ul> </DIV> <br> <h1 class="heading">Using this library</h1> <p>The following are links to information on various aspects of the library and how to use it in your application(s) </p> |
| | < < < |
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
<br> </DIV> <h1 class="heading">What's Coming Up?</h1> <p>There's a few things I'm aiming to do in the near future: </p> <DIV> <ul> <LI> Trigger design/view support from the Visual Studio Server Explorer and the ability to create/edit views.</LI> </ul> </DIV> <br> <h1 class="heading">Using this library</h1> <p>The following are links to information on various aspects of the library and how to use it in your application(s) </p> |
Changes to Doc/SQLite.NET.chm.
cannot compute difference between binary files
Changes to SQLite.Designer/Design/Column.cs.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 .. 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 .. 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 ... 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; using System.ComponentModel.Design; using System.Windows.Forms; using System.Drawing.Design; namespace SQLite.Designer.Design { internal class Column { private bool _allowNulls = false; private string _dataType = ""; private string _defaultValue = ""; private string _columnName = ""; private CollationTypeEnum _collate = CollationTypeEnum.Binary; private DataGridViewRow _parent; private string _checkconstraint = ""; private Unique _unique; private PrimaryKey _primaryKey; private Table _table; internal Column(DataGridViewRow row) { _parent = row; _table = row.Tag as Table; _unique = new Unique(this); _primaryKey = new PrimaryKey(this); } [Browsable(false)] internal Table Table { get { return _table; } } internal void RefreshGrid() { _parent.DataGridView.Refresh(); } internal void CellValueChanged() { if (_parent.DataGridView.CurrentCell.RowIndex != _parent.Index) return; object value; if (_parent.DataGridView.CurrentCell.IsInEditMode == true) { if (_parent.DataGridView.EditingControl != null) ................................................................................ } [DisplayName("Check")] [Category("Constraints")] public virtual string CheckConstraint { get { return _checkconstraint; } set { _checkconstraint = value; } } [DefaultValue(CollationTypeEnum.Binary)] [Category("Constraints")] public virtual CollationTypeEnum CollationType { get { return _collate; } set { _collate = value; } } [Category("Constraints")] public virtual Unique Unique { get { return _unique; } } ................................................................................ [Browsable(false)] public virtual string ColumnName { get { return _columnName; } set { _columnName = value; } } [DisplayName("Primary Key")] [Category("Constraints")] public virtual PrimaryKey PrimaryKey { get { return _primaryKey; } } [DefaultValue(false)] [DisplayName("Allow Nulls")] [Category("Constraints")] public virtual bool AllowNulls { get { return _allowNulls; } set { if (value != _allowNulls) { _allowNulls = value; _parent.Cells[2].Value = _allowNulls; } } } [Browsable(false)] public virtual string DataType ................................................................................ [DisplayName("Default Value")] [Category("Constraints")] public virtual string DefaultValue { get { return _defaultValue; } set { _defaultValue = value; } } } public enum CollationTypeEnum { Binary = 0, CaseInsensitive = 1, } } |
> > | | > | | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | > | | > > | | > > > > > | > > > > > > > > > | | | < > | < > > | > | < > > > | > > > | < > | > > | > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 ... 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 ... 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 ... 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; using System.ComponentModel.Design; using System.Windows.Forms; using System.Drawing.Design; using System.Data; using System.Data.Common; namespace SQLite.Designer.Design { internal class Column : IHaveConnection { private bool _allowNulls = false; private string _dataType = ""; private string _defaultValue = ""; private string _columnName = ""; private string _origName = ""; private string _collate; private DataGridViewRow _parent; private string _checkconstraint = ""; private Unique _unique; //private PrimaryKey _primaryKey; private Table _table; internal Column(Table table, DataGridViewRow row) { _parent = row; _table = table as Table; _unique = new Unique(this); //_primaryKey = new PrimaryKey(this); } internal Column(DataRow row, Table source) { _table = source; _unique = new Unique(this, row); //_primaryKey = new PrimaryKey(this, row); if (row.IsNull("AUTOINCREMENT") == false && (bool)row["AUTOINCREMENT"] == true) _table.PrimaryKey.AutoIncrement = true; _dataType = (row.IsNull("DATA_TYPE") == false) ? row["DATA_TYPE"].ToString() : String.Empty; _columnName = row["COLUMN_NAME"].ToString(); _origName = _columnName; _allowNulls = (bool)row["IS_NULLABLE"]; _defaultValue = (row.IsNull("COLUMN_DEFAULT") == false) ? row["COLUMN_DEFAULT"].ToString() : String.Empty; _collate = (row.IsNull("COLLATION_NAME") == false) ? row["COLLATION_NAME"].ToString() : String.Empty; string edmtype = (row.IsNull("EDM_TYPE") == false) ? row["EDM_TYPE"].ToString() : String.Empty; if (edmtype == "nvarchar" || edmtype == "varchar" || edmtype == "blob" || edmtype == "nchar" || edmtype == "char") { int size = (row.IsNull("CHARACTER_MAXIMUM_LENGTH") == false) ? Convert.ToInt32(row["CHARACTER_MAXIMUM_LENGTH"]) : int.MaxValue; if (size != int.MaxValue) _dataType = string.Format("{0}({1})", _dataType, size); } else if (edmtype == "decimal") { int size = (row.IsNull("NUMERIC_PRECISION") == false) ? Convert.ToInt32(row["NUMERIC_PRECISION"]) : 53; int scale = (row.IsNull("NUMERIC_SCALE") == false) ? Convert.ToInt32(row["NUMERIC_SCALE"]) : int.MaxValue; if (size != 53) { string scalestr = (scale == int.MaxValue) ? "" : String.Format(",{0}", scale); _dataType = string.Format("{0}({1}{2})", _dataType, size, scalestr); } } } #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_table).GetConnection(); } #endregion [Browsable(false)] internal Table Table { get { return _table; } } internal DataGridViewRow Parent { get { return _parent; } set { _parent = value; _parent.Cells[0].Value = ColumnName; _parent.Cells[1].Value = DataType; _parent.Cells[2].Value = AllowNulls; } } internal void RefreshGrid() { if (_parent == null) return; _parent.DataGridView.Refresh(); } internal void CellValueChanged() { if (_parent == null) return; if (_parent.DataGridView.CurrentCell.RowIndex != _parent.Index) return; object value; if (_parent.DataGridView.CurrentCell.IsInEditMode == true) { if (_parent.DataGridView.EditingControl != null) ................................................................................ } [DisplayName("Check")] [Category("Constraints")] public virtual string CheckConstraint { get { return _checkconstraint; } set { if (_checkconstraint != value) { _checkconstraint = value; _table._owner.MakeDirty(); } } } [DefaultValue("BINARY")] [Category("Constraints")] public virtual string Collate { get { return _collate; } set { if (String.IsNullOrEmpty(value)) value = "BINARY"; if (_collate != value) { _collate = value; _table._owner.MakeDirty(); } } } [Category("Constraints")] public virtual Unique Unique { get { return _unique; } } ................................................................................ [Browsable(false)] public virtual string ColumnName { get { return _columnName; } set { _columnName = value; } } [Browsable(false)] public virtual string OriginalName { get { return _origName; } } //[DisplayName("Primary Key")] //[Category("Constraints")] //public virtual PrimaryKey PrimaryKey //{ // get { return _primaryKey; } //} [DefaultValue(false)] [DisplayName("Allow Nulls")] [Category("Constraints")] public virtual bool AllowNulls { get { return _allowNulls; } set { if (value != _allowNulls) { _allowNulls = value; if (_parent == null) return; _parent.Cells[2].Value = _allowNulls; } } } [Browsable(false)] public virtual string DataType ................................................................................ [DisplayName("Default Value")] [Category("Constraints")] public virtual string DefaultValue { get { return _defaultValue; } set { _defaultValue = value; } } internal void WriteSql(StringBuilder builder) { builder.AppendFormat("[{0}]", ColumnName); if (String.IsNullOrEmpty(DataType) == false) builder.AppendFormat(" {0}", DataType); bool isprimary = false; if (_table.PrimaryKey.Columns.Count == 1 && String.Compare(_table.PrimaryKey.Columns[0].Column, ColumnName, StringComparison.OrdinalIgnoreCase) == 0) { isprimary = true; builder.Append(" PRIMARY KEY"); if (_table.PrimaryKey.Columns[0].SortMode != ColumnSortMode.Ascending) builder.Append(" DESC"); if (_table.PrimaryKey.Conflict != ConflictEnum.Abort) builder.AppendFormat(" ON CONFLICT {0}", _table.PrimaryKey.Conflict.ToString()); if (_table.PrimaryKey.AutoIncrement == true) builder.Append(" AUTOINCREMENT"); } if (AllowNulls == false) builder.Append(" NOT NULL"); if (Unique.Enabled == true && isprimary == false) { builder.Append(" UNIQUE"); if (Unique.Conflict != ConflictEnum.Abort) builder.AppendFormat(" ON CONFLICT {0}", Unique.Conflict.ToString()); } if (String.IsNullOrEmpty(CheckConstraint) == false) { builder.AppendFormat(" CONSTRAINT CK_{0}_{1} CHECK ({2})", _table.Name, ColumnName, CheckConstraint); } } } } |
Added SQLite.Designer/Design/ForeignKey.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 |
using System; using System.Collections.Generic; using System.Collections; using System.Text; using System.ComponentModel; using System.Data; using System.Data.Common; using System.ComponentModel.Design; using System.Drawing.Design; using System.Windows.Forms; namespace SQLite.Designer.Design { internal class ForeignKeyEditor : CollectionEditor { Table _table; bool _cancel = false; object[] _items; internal ForeignKeyEditor(Table parent) : base(typeof(List<ForeignKey>)) { _table = parent; } protected override object CreateInstance(Type itemType) { if (itemType == typeof(ForeignKey)) { return new ForeignKey(null, _table, null); } throw new NotSupportedException(); } protected override object[] GetItems(object editValue) { if (_items == null) { List<ForeignKey> value = editValue as List<ForeignKey>; _items = new object[value.Count]; for (int n = 0; n < _items.Length; n++) _items[n] = value[n].Clone(); } return _items; } protected override object SetItems(object editValue, object[] value) { if (editValue != null) { int length = this.GetItems(editValue).Length; int num2 = value.Length; if (!(editValue is IList)) { return editValue; } IList list = (IList)editValue; list.Clear(); for (int i = 0; i < value.Length; i++) { ForeignKey fkey = value[i] as ForeignKey; if (fkey != null && String.IsNullOrEmpty(fkey.From.Column) == false && String.IsNullOrEmpty(fkey.To.Catalog) == false && String.IsNullOrEmpty(fkey.To.Table) == false && String.IsNullOrEmpty(fkey.To.Column) == false) list.Add(value[i]); } } if (_cancel == false) _table._owner.MakeDirty(); return editValue; } protected override void CancelChanges() { _cancel = true; } } internal class ForeignKeyItem : IHaveConnectionScope { private string _catalog; private string _table; private string _column; private ForeignKey _fkey; internal ForeignKeyItem(ForeignKey fkey, string catalog, string table, string column) { _catalog = catalog; _table = table; _column = column; _fkey = fkey; } public override string ToString() { return String.Format("[{0}].[{1}].[{2}]", _catalog, _table, _column); } #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_fkey).GetConnection(); } [Browsable(false)] public string TableScope { get { return _table; } } [Browsable(false)] public string CatalogScope { get { return _catalog; } } #endregion [Browsable(false)] [Editor(typeof(CatalogTypeEditor), typeof(UITypeEditor))] public virtual string Catalog { get { return _catalog; } } [Editor(typeof(TablesTypeEditor), typeof(UITypeEditor))] public virtual string Table { get { return _table; } } [Editor(typeof(ColumnsTypeEditor), typeof(UITypeEditor))] public virtual string Column { get { return _column; } } protected void SetCatalog(string value) { _catalog = value; } protected void SetTable(string value) { _table = value; } protected void SetColumn(string value) { _column = value; } } [TypeConverter(typeof(ExpandableObjectConverter))] internal class ForeignKeyFromItem : ForeignKeyItem { internal ForeignKeyFromItem(ForeignKey fkey, string column) : base(fkey, fkey._table.Catalog, fkey._table.Name, column) { } [Editor(typeof(ColumnsTypeEditor), typeof(UITypeEditor))] public new string Column { get { return base.Column; } set { SetColumn(value); } } [Browsable(false)] public override string Catalog { get { return base.Catalog; } } [Browsable(false)] public override string Table { get { return base.Table; } } } [TypeConverter(typeof(ExpandableObjectConverter))] internal class ForeignKeyToItem : ForeignKeyItem { internal ForeignKeyToItem(ForeignKey fkey, string catalog, string table, string column) : base(fkey, catalog, table, column) { } [Browsable(false)] [Editor(typeof(CatalogTypeEditor), typeof(UITypeEditor))] public new string Catalog { get { return base.Catalog; } set { SetCatalog(value); } } [DisplayName("Base Table")] [Editor(typeof(TablesTypeEditor), typeof(UITypeEditor))] public new string Table { get { return base.Table; } set { SetTable(value); } } [Editor(typeof(ColumnsTypeEditor), typeof(UITypeEditor))] public new string Column { get { return base.Column; } set { SetColumn(value); } } } [DefaultProperty("From")] internal class ForeignKey : IHaveConnection, ICloneable { internal Table _table; internal ForeignKeyFromItem _from; internal ForeignKeyToItem _to; internal string _name; private ForeignKey(ForeignKey source) { _table = source._table; _from = new ForeignKeyFromItem(this, source._from.Column); _to = new ForeignKeyToItem(this, source._to.Catalog, source._to.Table, source._to.Column); _name = source._name; } internal ForeignKey(DbConnection cnn, Table table, DataRow row) { _table = table; if (row != null) { _from = new ForeignKeyFromItem(this, row["FKEY_FROM_COLUMN"].ToString()); _to = new ForeignKeyToItem(this, row["FKEY_TO_CATALOG"].ToString(), row["FKEY_TO_TABLE"].ToString(), row["FKEY_TO_COLUMN"].ToString()); _name = row["CONSTRAINT_NAME"].ToString(); } else { _name = null; _from = new ForeignKeyFromItem(this, ""); _to = new ForeignKeyToItem(this, _table.Catalog, "", ""); } } internal void WriteSql(StringBuilder builder) { if (String.IsNullOrEmpty(_from.Column) == false && String.IsNullOrEmpty(_to.Catalog) == false && String.IsNullOrEmpty(_to.Table) == false && String.IsNullOrEmpty(_to.Column) == false) { builder.AppendFormat("CONSTRAINT [{0}] FOREIGN KEY ([{1}]) REFERENCES [{3}] ([{4}])", Name, _from.Column, _to.Catalog, _to.Table, _to.Column); } } [ParenthesizePropertyName(true)] [Category("Identity")] public string Name { get { if (String.IsNullOrEmpty(_name) == false) return _name; return String.Format("FK_{0}_{1}_{2}_{3}", _from.Table, _from.Column, _to.Table, _to.Column); } set { _name = value; } } #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_table).GetConnection(); } #endregion [DisplayName("Primary/Unique Key")] [Category("Source")] public ForeignKeyFromItem From { get { return _from; } } [DisplayName("Foreign Key")] [Category("Target")] public ForeignKeyToItem To { get { return _to; } } #region ICloneable Members public object Clone() { return new ForeignKey(this); } #endregion } } |
Added SQLite.Designer/Design/Index.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 |
using System; using System.Collections.Generic; using System.Collections; using System.Text; using System.ComponentModel; using System.Data; using System.Data.Common; using System.ComponentModel.Design; using System.Drawing.Design; using System.Windows.Forms; namespace SQLite.Designer.Design { internal class IndexEditor : CollectionEditor { Table _table; bool _cancel = false; object[] _items; internal IndexEditor(Table parent) : base(typeof(List<Index>)) { _table = parent; } protected override object CreateInstance(Type itemType) { if (itemType == typeof(Index)) { return new Index(null, _table, null); } throw new NotSupportedException(); } protected override void CancelChanges() { _cancel = true; } protected override bool CanRemoveInstance(object value) { return !(value is PrimaryKey); } protected override object[] GetItems(object editValue) { if (_items == null) { List<Index> value = editValue as List<Index>; int extra = (_table.PrimaryKey.Columns.Count > 0) ? 1 : 0; _items = new object[value.Count + extra]; for (int n = extra; n < _items.Length; n++) _items[n] = ((ICloneable)value[n - extra]).Clone(); if (extra > 0) _items[0] = _table.PrimaryKey; } return _items; } protected override object SetItems(object editValue, object[] value) { if (editValue != null) { int length = this.GetItems(editValue).Length; int num2 = value.Length; if (!(editValue is IList)) { return editValue; } IList list = (IList)editValue; list.Clear(); for (int i = 0; i < value.Length; i++) { Index idx = value[i] as Index; if (idx is PrimaryKey) { _table.PrimaryKey = (PrimaryKey)idx; } else { if (idx != null && idx.Columns.Count > 0) list.Add(value[i]); } } } if (_cancel == false) _table._owner.MakeDirty(); return editValue; } } internal class IndexColumnEditor : CollectionEditor { Index _index; bool _cancel = false; object[] _items; public IndexColumnEditor() : base(typeof(List<IndexColumn>)) { } public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) { _index = context.Instance as Index; _items = null; _cancel = false; return base.EditValue(context, provider, value); } protected override object CreateInstance(Type itemType) { if (itemType == typeof(IndexColumn)) { return new IndexColumn(_index, null); } throw new NotSupportedException(); } protected override void CancelChanges() { _cancel = true; } protected override object[] GetItems(object editValue) { if (_items == null) { List<IndexColumn> value = editValue as List<IndexColumn>; _items = new object[value.Count]; for (int n = 0; n < _items.Length; n++) _items[n] = value[n].Clone(); } return _items; } protected override object SetItems(object editValue, object[] value) { if (editValue != null) { int length = this.GetItems(editValue).Length; int num2 = value.Length; if (!(editValue is IList)) { return editValue; } IList list = (IList)editValue; list.Clear(); for (int i = 0; i < value.Length; i++) { IndexColumn idx = value[i] as IndexColumn; if (idx != null && String.IsNullOrEmpty(idx.Column) == false) list.Add(value[i]); } } if (_cancel == false) { if (_index.Columns.Count > 0 && String.IsNullOrEmpty(_index._name) == true) _index.Name = _index.Name; _index.Table._owner.MakeDirty(); } return editValue; } } internal class IndexTypeConverter : TypeConverter { public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { if (sourceType == typeof(string)) return true; return base.CanConvertFrom(context, sourceType); } public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { if (destinationType == typeof(string)) return true; return base.CanConvertTo(context, destinationType); } public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { if (destinationType == typeof(string)) { StringBuilder builder = new StringBuilder(); string separator = ""; foreach (IndexColumn c in (List<IndexColumn>)value) { builder.AppendFormat("{0}[{1}]", separator, c.Column); if (c.SortMode != ColumnSortMode.Ascending) builder.Append(" DESC"); if (c.Collate != "BINARY") builder.AppendFormat(" COLLATE {0}", c.Collate); separator = ", "; } return builder.ToString(); } else return base.ConvertTo(context, culture, value, destinationType); } } internal enum ColumnSortMode { Ascending = 0, Descending = 1 } [DefaultProperty("Column")] internal class IndexColumn : IHaveConnectionScope, ICloneable { private Index _parent; private string _column; private ColumnSortMode _mode = ColumnSortMode.Ascending; private string _collate = "BINARY"; [Editor(typeof(ColumnsTypeEditor), typeof(UITypeEditor))] [DisplayName("Base Column")] public string Column { get { return _column; } set { _column = value; } } [DefaultValue(ColumnSortMode.Ascending)] public ColumnSortMode SortMode { get { return _mode; } set { _mode = value; } } [DefaultValue("BINARY")] public string Collate { get { return _collate; } set { if (String.IsNullOrEmpty(value)) _collate = "BINARY"; else _collate = value; } } public override string ToString() { if (String.IsNullOrEmpty(_column) == true) return "(none)"; return _column; } private IndexColumn(IndexColumn source) { _parent = source._parent; _column = source._column; _mode = source._mode; _collate = source._collate; } internal IndexColumn(Index parent, DataRow row) { _parent = parent; if (row != null) { _column = row["COLUMN_NAME"].ToString(); //.Trim().TrimStart('[').TrimEnd(']') if (row.IsNull("SORT_MODE") == false && (string)row["SORT_MODE"] != "ASC") _mode = ColumnSortMode.Descending; if (row.IsNull("COLLATION_NAME") == false && (string)row["COLLATION_NAME"] != "BINARY") _collate = row["COLLATION_NAME"].ToString(); } } public object Clone() { return new IndexColumn(this); } #region IHaveConnectionScope Members [Browsable(false)] public string CatalogScope { get { return _parent.Table.Catalog; } } [Browsable(false)] public string TableScope { get { return _parent.Table.Name; } } #endregion #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_parent).GetConnection(); } #endregion } public enum IndexTypeEnum { Index = 0, PrimaryKey = 1, } [DefaultProperty("Columns")] internal class Index : IHaveConnection, ICloneable { private Table _table; internal string _name = null; private bool _unique; private List<IndexColumn> _columns = new List<IndexColumn>(); private string _definition; private bool _calcname; internal ConflictEnum _conflict = ConflictEnum.Abort; protected Index(Index source) { _table = source._table; _name = source._name; _unique = source._unique; _columns = source._columns; _definition = source._definition; _conflict = source._conflict; } internal Index(DbConnection cnn, Table table, DataRow index) { _table = table; if (index != null) { _name = index["INDEX_NAME"].ToString(); _unique = (bool)index["UNIQUE"]; _definition = index["INDEX_DEFINITION"].ToString(); using (DataTable tbl = cnn.GetSchema("IndexColumns", new string[] { table.Catalog, null, table.Name, Name })) { foreach (DataRow row in tbl.Rows) { _columns.Add(new IndexColumn(this, row)); //builder.AppendFormat("{0}[{1}]", separator, row["COLUMN_NAME"]); //if (row.IsNull("SORT_MODE") == false && (string)row["SORT_MODE"] != "ASC") // builder.AppendFormat(" {0}", row["SORT_MODE"]); //if (row.IsNull("COLLATION_NAME") == false && (string)row["COLLATION_NAME"] != "BINARY") // builder.AppendFormat(" COLLATE {0}", row["COLLATION_NAME"]); //separator = ", "; } } } } [DisplayName("Index Type")] public virtual IndexTypeEnum IndexType { get { return IndexTypeEnum.Index; } } #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_table).GetConnection(); } #endregion internal virtual void WriteSql(StringBuilder builder) { string separator = ""; builder.AppendFormat("CREATE {0}INDEX [{1}].[{2}] ON [{3}] (", (_unique == true) ? "UNIQUE " : "", _table.Catalog, Name, _table.Name); foreach (IndexColumn c in Columns) { builder.AppendFormat("{0}[{1}]", separator, c.Column); if (c.SortMode != ColumnSortMode.Ascending) builder.Append(" DESC"); if (c.Collate != "BINARY") builder.AppendFormat(" COLLATE {0}", c.Collate); separator = ", "; } builder.AppendFormat(");"); } [Browsable(false)] internal Table Table { get { return _table; } } [Browsable(false)] public string OriginalSql { get { return _definition; } } [DefaultValue(false)] public virtual bool Unique { get { return _unique; } set { _unique = value; } } [Browsable(false)] protected virtual string NamePrefix { get { return "IX"; } } [Browsable(false)] protected virtual string NewName { get { return "NewIndex"; } } [ParenthesizePropertyName(true)] [RefreshProperties(RefreshProperties.All)] public virtual string Name { get { if (String.IsNullOrEmpty(_name)) { if (_calcname == true) return GetHashCode().ToString(); string name = String.Format("{0}_{1}", NamePrefix, NewName); if (Columns.Count > 0 && NewName != Table.Name) { name = String.Format("{0}_", NamePrefix); for (int n = 0; n < Columns.Count; n++) { if (n > 0) name += "_"; name += Columns[n].Column; } } int count = 0; string proposed = name; _calcname = true; for (int n = 0; n < _table.Indexes.Count; n++) { Index idx = _table.Indexes[n]; proposed = string.Format("{0}{1}", name, (count > 0) ? count.ToString() : ""); if (idx.Name == proposed) { count++; n = -1; } } _calcname = false; return proposed; } return _name; } set { _name = value; } } [TypeConverter(typeof(IndexTypeConverter))] [Editor(typeof(IndexColumnEditor), typeof(UITypeEditor))] [RefreshProperties(RefreshProperties.All)] public List<IndexColumn> Columns { get { return _columns; } } #region ICloneable Members object ICloneable.Clone() { return new Index(this); } #endregion } public class ColumnsMultiSelectEditor : UITypeEditor { private System.Windows.Forms.Design.IWindowsFormsEditorService _edSvc; private CheckedListBox _list; private bool _cancel; public ColumnsMultiSelectEditor() { // build selector list _list = new CheckedListBox(); _list.BorderStyle = BorderStyle.FixedSingle; _list.CheckOnClick = true; _list.ThreeDCheckBoxes = false; _list.KeyPress += new KeyPressEventHandler(_list_KeyPress); } override public UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext ctx) { return UITypeEditorEditStyle.DropDown; } override public object EditValue(ITypeDescriptorContext ctx, IServiceProvider provider, object value) { Index idx = ctx.Instance as Index; Table parent = idx.Table; // initialize editor service _edSvc = (System.Windows.Forms.Design.IWindowsFormsEditorService)provider.GetService(typeof(System.Windows.Forms.Design.IWindowsFormsEditorService)); if (_edSvc == null) return value; if (value == null) value = String.Empty; if (String.IsNullOrEmpty(value.ToString()) == true) value = String.Empty; string[] values = value.ToString().Split(','); // populate the list _list.Items.Clear(); using (DataTable tbl = parent._connection.GetSchema("Columns", new string[] { parent.Catalog, null, parent.Name })) { foreach (DataRow item in tbl.Rows) { // add this item with the proper check state CheckState check = CheckState.Unchecked; for (int n = 0; n < values.Length; n++) { if (values[n].Trim() == String.Format("[{0}]", item["COLUMN_NAME"].ToString())) { check = CheckState.Checked; break; } } _list.Items.Add(item["COLUMN_NAME"].ToString(), check); } } _list.Height = Math.Min(300, (_list.Items.Count + 1) * _list.Font.Height); // show the list _cancel = false; _edSvc.DropDownControl(_list); // build return value from checked items on the list if (!_cancel) { // build a comma-delimited string with the checked items StringBuilder sb = new StringBuilder(); foreach (object item in _list.CheckedItems) { if (sb.Length > 0) sb.Append(", "); sb.AppendFormat("[{0}]", item.ToString()); } return sb.ToString(); } // done return value; } // ** event handlers // close editor if the user presses enter or escape private void _list_KeyPress(object sender, KeyPressEventArgs e) { switch (e.KeyChar) { case (char)27: _cancel = true; _edSvc.CloseDropDown(); break; case (char)13: _edSvc.CloseDropDown(); break; } } } internal class ColumnsTypeEditor : ObjectSelectorEditor { public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) { return UITypeEditorEditStyle.DropDown; } protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); IHaveConnectionScope source = context.Instance as IHaveConnectionScope; if (source == null) return; using (DataTable table = source.GetConnection().GetSchema("Columns", new string[] { source.CatalogScope, null, source.TableScope })) { foreach (DataRow row in table.Rows) { selector.AddNode(row[3].ToString(), row[3], null); } } } } internal class TablesTypeEditor : ObjectSelectorEditor { public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) { return UITypeEditorEditStyle.DropDown; } protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); IHaveConnectionScope source = context.Instance as IHaveConnectionScope; if (source == null) return; using (DataTable table = source.GetConnection().GetSchema("Tables", new string[] { source.CatalogScope })) { foreach (DataRow row in table.Rows) { selector.AddNode(row[2].ToString(), row[2], null); } } } } } |
Changes to SQLite.Designer/Design/PrimaryKey.cs.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; namespace SQLite.Designer.Design { [TypeConverter(typeof(ExpandableObjectConverter))] internal class PrimaryKey { private bool _primaryKey; private bool _autoIncrement; private IndexDirection _direction; private ConflictEnum _conflict; Column _column; internal PrimaryKey(Column col) { _column = col; } [RefreshProperties(RefreshProperties.All)] [DefaultValue(false)] public bool Enabled { get { return _primaryKey; } set { _primaryKey = value; if (_primaryKey == false) AutoIncrement = false; _column.RefreshGrid(); } } [RefreshProperties(RefreshProperties.All)] [DefaultValue(false)] [DisplayName("Auto Increment")] public bool AutoIncrement { get { return _autoIncrement; } set { if (_primaryKey == false && value == true) Enabled = true; _autoIncrement = value; } } [DefaultValue(ConflictEnum.Abort)] [DisplayName("On Conflict")] public ConflictEnum Conflict { get { return _conflict; } set { _conflict = value; } } [DefaultValue(IndexDirection.Ascending)] [DisplayName("Sort Mode")] public IndexDirection SortMode { get { return _direction; } set { _direction = value; } } public override string ToString() { return Enabled.ToString(); } } internal enum IndexDirection { Ascending = 0, Descending = 1, } } |
> > < | < | < < < | > < > > > > > | < < > | < > > | | | < < | < > > > > > > > > > > > > > > | | | | | | | | | | < < | | < < > > | > > | > | < | < > | > > > | < < < < > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; using System.Data; using System.Data.Common; namespace SQLite.Designer.Design { internal class PrimaryKey : Index, ICloneable { private bool _autoincrement; internal PrimaryKey(DbConnection cnn, Table table, DataRow row) : base(cnn, table, row) { if (String.IsNullOrEmpty(_name) == false && _name.StartsWith("sqlite_", StringComparison.OrdinalIgnoreCase)) _name = null; } protected PrimaryKey(PrimaryKey source) : base(source) { _autoincrement = source._autoincrement; } public override IndexTypeEnum IndexType { get { return IndexTypeEnum.PrimaryKey; } } protected override string NamePrefix { get { return "PK"; } } protected override string NewName { get { return Table.Name; } } [Browsable(false)] public override bool Unique { get { return true; } set { base.Unique = true; } } [DefaultValue(ConflictEnum.Abort)] [DisplayName("On Conflict")] public ConflictEnum Conflict { get { return _conflict; } set { _conflict = value; } } [DefaultValue(false)] public bool AutoIncrement { get { if (Columns.Count > 1) return false; if (Columns.Count == 1 && Columns[0].SortMode != ColumnSortMode.Ascending) return false; return _autoincrement; } set { _autoincrement = value; } } #region ICloneable Members object ICloneable.Clone() { return new PrimaryKey(this); } #endregion } } |
Changes to SQLite.Designer/Design/Table.cs.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
namespace SQLite.Designer.Design { using System; using System.Data.Common; using System.ComponentModel.Design; using System.ComponentModel; using System.Drawing.Design; using System.Data; using SQLite.Designer.Editors; internal class Table { private string _name; string _catalog; internal TableDesignerDoc _owner; internal DbConnection _connection; internal Table(string tableName, DbConnection connection, TableDesignerDoc owner) { _owner = owner; _connection = connection; Name = tableName; Catalog = _connection.Database; // main } [Category("Storage")] [RefreshProperties(RefreshProperties.All)] public string Name { get { return _name; } set { _name = value; _owner.Name = value; } } [Category("Storage")] [Editor(typeof(CatalogTypeEditor), typeof(UITypeEditor))] [DefaultValue("main")] [RefreshProperties(RefreshProperties.All)] public string Catalog { get { return _catalog; } set { string catalogs = ""; using (DataTable table = _connection.GetSchema("Catalogs")) { foreach (DataRow row in table.Rows) { catalogs += (row[0].ToString() + ","); } } if (catalogs.IndexOf(value + ",", StringComparison.OrdinalIgnoreCase) == -1) throw new ArgumentOutOfRangeException("Unrecognized catalog!"); _catalog = value; } } } internal class CatalogTypeEditor : ObjectSelectorEditor { public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) { return UITypeEditorEditStyle.DropDown; } protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); Table source = context.Instance as Table; if (source == null) return; using (DataTable table = source._connection.GetSchema("Catalogs")) { foreach (DataRow row in table.Rows) { selector.AddNode(row[0].ToString(), row[0], null); } } } } } |
> > | > | < > > > > > > > > > > > | > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | > | | | > > > > > > | < > | | < > | < > | > > | < < | | | > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 |
namespace SQLite.Designer.Design { using System; using System.Data.Common; using System.ComponentModel.Design; using System.ComponentModel; using System.Drawing.Design; using System.Collections.Generic; using System.Data; using System.Text; using SQLite.Designer.Editors; internal class Table : ICustomTypeDescriptor, IHaveConnection { private string _name; private string _oldname; private string _catalog; private List<Column> _columns = new List<Column>(); private bool _exists = false; private bool _hascheck = false; private string _origSql = String.Empty; private List<Index> _indexes = new List<Index>(); private List<Index> _oldindexes = new List<Index>(); private List<ForeignKey> _fkeys = new List<ForeignKey>(); private List<ForeignKey> _oldfkeys = new List<ForeignKey>(); private PrimaryKey _key; internal TableDesignerDoc _owner; internal DbConnection _connection; internal Table(string tableName, DbConnection connection, TableDesignerDoc owner) { _owner = owner; _oldname = tableName; _connection = connection; _name = tableName; _owner.Name = _name; _catalog = _connection.Database; // main ReloadDefinition(); if (_key == null) _key = new PrimaryKey(_connection, this, null); if (_exists) { using (DataTable tbl = connection.GetSchema("ForeignKeys", new string[] { Catalog, null, Name })) { foreach (DataRow row in tbl.Rows) { _fkeys.Add(new ForeignKey(connection, this, row)); _oldfkeys.Add(new ForeignKey(connection, this, row)); } } } using (DataTable tbl = connection.GetSchema("Columns", new string[] { Catalog, null, Name })) { foreach (DataRow row in tbl.Rows) { _columns.Add(new Column(row, this)); } } } private void ReloadDefinition() { using (DataTable tbl = _connection.GetSchema("Tables", new string[] { Catalog, null, Name })) { if (tbl.Rows.Count > 0) { _exists = true; _hascheck = (bool)tbl.Rows[0]["HAS_CHECKCONSTRAINTS"]; _origSql = tbl.Rows[0]["TABLE_DEFINITION"].ToString().Trim().TrimEnd(';'); } else { _exists = false; return; } } _indexes.Clear(); _oldindexes.Clear(); using (DataTable tbl = _connection.GetSchema("Indexes", new string[] { Catalog, null, Name })) { foreach (DataRow row in tbl.Rows) { if ((bool)row["PRIMARY_KEY"] == false) { if (row["INDEX_NAME"].ToString().StartsWith("sqlite_", StringComparison.OrdinalIgnoreCase) == false) { _indexes.Add(new Index(_connection, this, row)); _oldindexes.Add(new Index(_connection, this, row)); } } else if (_key == null) { _key = new PrimaryKey(_connection, this, row); } } } StringBuilder builder = new StringBuilder(); builder.Append(_origSql); builder.AppendLine(";"); foreach (Index idx in _oldindexes) { builder.AppendFormat("{0};\r\n", idx.OriginalSql); } _origSql = builder.ToString(); } internal void Committed() { _exists = true; ReloadDefinition(); } [Browsable(false)] public List<Index> Indexes { get { return _indexes; } } [Browsable(false)] public PrimaryKey PrimaryKey { get { return _key; } set { _key = value; _owner.Invalidate(); } } [Browsable(false)] public List<ForeignKey> ForeignKeys { get { return _fkeys; } } [Browsable(false)] public string OriginalSql { get { return _origSql; } } [Browsable(false)] public bool HasCheck { get { return _hascheck; } } [Category("Storage")] [RefreshProperties(RefreshProperties.All)] [ParenthesizePropertyName(true)] public string Name { get { return _name; } set { if (_name != value) { _name = value; _owner.Name = value; _owner.MakeDirty(); } } } public override string ToString() { return String.Format("[{0}].[{1}]", Catalog, Name); } [Category("Storage")] [Editor(typeof(CatalogTypeEditor), typeof(UITypeEditor))] [DefaultValue("main")] [RefreshProperties(RefreshProperties.All)] public string Catalog { get { return _catalog; } //set //{ // string catalogs = ""; // using (DataTable table = _connection.GetSchema("Catalogs")) // { // foreach (DataRow row in table.Rows) // { // catalogs += (row[0].ToString() + ","); // } // } // if (catalogs.IndexOf(value + ",", StringComparison.OrdinalIgnoreCase) == -1) // throw new ArgumentOutOfRangeException("Unrecognized catalog!"); // _catalog = value; //} } [Category("Storage")] public string Database { get { return _connection.DataSource; } } [Browsable(false)] public List<Column> Columns { get { return _columns; } } public string GetSql() { StringBuilder builder = new StringBuilder(); string altName = null; if (_exists) { Guid g = Guid.NewGuid(); altName = String.Format("{0}_{1}", Name, g.ToString("N")); foreach (Index idx in _oldindexes) { builder.AppendFormat("DROP INDEX [{0}].[{1}];\r\n", _catalog, idx.Name); } builder.AppendFormat("ALTER TABLE [{0}].[{1}] RENAME TO [{2}];\r\n", _catalog, _oldname, altName); } builder.AppendFormat("CREATE TABLE [{0}].[{1}] (\r\n", _catalog, Name); string separator = " "; foreach (Column c in Columns) { builder.Append(separator); c.WriteSql(builder); separator = ",\r\n "; } if (_key.Columns.Count > 1) { string innersep = ""; builder.AppendFormat("{0}CONSTRAINT PK_{1} PRIMARY KEY (", separator, Name); foreach (IndexColumn c in _key.Columns) { builder.AppendFormat("{0}[{1}]{2}", innersep, c.Column, (c.SortMode == ColumnSortMode.Ascending) ? "" : " DESC"); innersep = ", "; } builder.Append(")"); if (_key.Conflict != ConflictEnum.Abort) builder.AppendFormat(" ON CONFLICT {0}", _key.Conflict.ToString()); } foreach (ForeignKey fkey in ForeignKeys) { builder.Append(separator); fkey.WriteSql(builder); } builder.Append("\r\n);\r\n"); // Rebuilding an existing table if (altName != null) { separator = ""; builder.AppendFormat("INSERT INTO [{0}].[{1}] (", _catalog, Name); foreach (Column c in Columns) { if (String.IsNullOrEmpty(c.OriginalName) == false) { builder.AppendFormat("{1}[{0}]", c.ColumnName, separator); separator = ", "; } } builder.Append(") SELECT "); separator = ""; foreach (Column c in Columns) { if (String.IsNullOrEmpty(c.OriginalName) == false) { builder.AppendFormat("{1}[{0}]", c.OriginalName, separator); separator = ", "; } } builder.AppendFormat(" FROM [{0}].[{1}];\r\n", _catalog, altName); builder.AppendFormat("DROP TABLE [{0}].[{1}];\r\n", _catalog, altName); } separator = ""; foreach (Index idx in _indexes) { builder.Append(separator); idx.WriteSql(builder); separator = "\r\n"; } return builder.ToString(); } #region IHaveConnection Members public DbConnection GetConnection() { return _connection; } #endregion #region ICustomTypeDescriptor Members AttributeCollection ICustomTypeDescriptor.GetAttributes() { return TypeDescriptor.GetAttributes(GetType()); } string ICustomTypeDescriptor.GetClassName() { return "Table Design"; } string ICustomTypeDescriptor.GetComponentName() { return ToString(); } TypeConverter ICustomTypeDescriptor.GetConverter() { return TypeDescriptor.GetConverter(GetType()); } EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() { return TypeDescriptor.GetDefaultEvent(GetType()); } PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() { return TypeDescriptor.GetDefaultProperty(GetType()); } object ICustomTypeDescriptor.GetEditor(Type editorBaseType) { return TypeDescriptor.GetEditor(GetType(), editorBaseType); } EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) { return TypeDescriptor.GetEvents(GetType(), attributes); } EventDescriptorCollection ICustomTypeDescriptor.GetEvents() { return TypeDescriptor.GetEvents(GetType()); } PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) { return TypeDescriptor.GetProperties(GetType(), attributes); } PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() { return TypeDescriptor.GetProperties(GetType()); } object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) { return this; } #endregion } internal interface IHaveConnection { DbConnection GetConnection(); } internal interface IHaveConnectionScope : IHaveConnection { [Browsable(false)] string CatalogScope { get; } [Browsable(false)] string TableScope { get; } } internal class CatalogTypeEditor : ObjectSelectorEditor { public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) { return UITypeEditorEditStyle.DropDown; } protected override void FillTreeWithData(Selector selector, ITypeDescriptorContext context, IServiceProvider provider) { base.FillTreeWithData(selector, context, provider); IHaveConnection source = context.Instance as IHaveConnection; if (source == null) return; using (DataTable table = source.GetConnection().GetSchema("Catalogs")) { foreach (DataRow row in table.Rows) { selector.AddNode(row[0].ToString(), row[0], null); } } } } } |
Changes to SQLite.Designer/Design/Unique.cs.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; namespace SQLite.Designer.Design { [TypeConverter(typeof(ExpandableObjectConverter))] internal class Unique { private bool _isUnique; private ConflictEnum _conflict; private Column _column; internal Unique(Column col) { _column = col; } [DefaultValue(false)] [DisplayName("Enabled")] public bool Enabled { get { return _isUnique; } set { _isUnique = value; } } [DefaultValue(ConflictEnum.Abort)] [DisplayName("On Conflict")] public ConflictEnum Conflict { get { return _conflict; } set { _conflict = value; } } public override string ToString() { if (_isUnique == false) return Convert.ToString(false); else return String.Format("{0} ({1})", Convert.ToString(true), Convert.ToString(Conflict)); } } public enum ConflictEnum { Abort = 0, Rollback, Fail, Ignore, Replace, } } |
> > > | | > > > > > > > > | > > > > > > > > > > > > > > > | > > > > > > > | > > > > | | | | | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
using System; using System.Collections.Generic; using System.Text; using System.ComponentModel; using System.Data; using System.Data.Common; namespace SQLite.Designer.Design { [TypeConverter(typeof(ExpandableObjectConverter))] [DefaultProperty("Enabled")] internal class Unique : IHaveConnection { private bool _isUnique; private ConflictEnum _conflict = ConflictEnum.Abort; private Column _column; internal Unique(Column col) : this(col, null) { } internal Unique(Column col, DataRow row) { _column = col; if (row != null) { _isUnique = (row.IsNull("UNIQUE") == false) ? (bool)row["UNIQUE"] : false; } } #region IHaveConnection Members public DbConnection GetConnection() { return ((IHaveConnection)_column).GetConnection(); } #endregion [DefaultValue(false)] [DisplayName("Enabled")] public bool Enabled { get { return _isUnique; } set { if (value != _isUnique) { _isUnique = value; _column.Table._owner.MakeDirty(); } } } [DefaultValue(ConflictEnum.Abort)] [DisplayName("On Conflict")] public ConflictEnum Conflict { get { return _conflict; } set { if (_conflict != value) { _conflict = value; _column.Table._owner.MakeDirty(); } } } public override string ToString() { if (_isUnique == false) return Convert.ToString(false); else return String.Format("{0} ({1})", Convert.ToString(true), Convert.ToString(Conflict)); //return Convert.ToString(true); } } public enum ConflictEnum { Abort = 2, Rollback = 0, Fail = 3, Ignore = 4, Replace = 5, } } |
Added SQLite.Designer/Design/View.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
namespace SQLite.Designer.Design { using System; using System.Data.Common; using System.ComponentModel.Design; using System.ComponentModel; using System.Drawing.Design; using System.Collections.Generic; using System.Data; using System.Text; using SQLite.Designer.Editors; internal class View : ICustomTypeDescriptor, IHaveConnection { private string _name; private string _oldname; private string _sql; private string _oldsql; private ViewDesignerDoc _owner; private string _catalog; private DbConnection _connection; internal View(string viewName, DbConnection connection, ViewDesignerDoc parent) { _owner = parent; _name = viewName; _oldname = viewName; _catalog = connection.Database; _connection = connection; _owner.Name = _name; if (String.IsNullOrEmpty(viewName) == false) { using (DataTable tbl = connection.GetSchema("Views", new string[] { Catalog, null, Name })) { if (tbl.Rows.Count > 0) { _sql = tbl.Rows[0]["VIEW_DEFINITION"].ToString(); _oldsql = _sql; } else { _oldname = null; } } } } public void Committed() { _oldsql = _sql; _oldname = _name; } public override string ToString() { return String.Format("[{0}].[{1}]", Catalog, Name); } [Category("Storage")] [RefreshProperties(RefreshProperties.All)] [ParenthesizePropertyName(true)] public string Name { get { return _name; } set { if (_name != value) { _name = value; _owner.Name = value; _owner.MakeDirty(); } } } [Category("Storage")] [Editor(typeof(CatalogTypeEditor), typeof(UITypeEditor))] [DefaultValue("main")] [RefreshProperties(RefreshProperties.All)] public string Catalog { get { return _catalog; } //set //{ // string catalogs = ""; // using (DataTable table = _connection.GetSchema("Catalogs")) // { // foreach (DataRow row in table.Rows) // { // catalogs += (row[0].ToString() + ","); // } // } // if (catalogs.IndexOf(value + ",", StringComparison.OrdinalIgnoreCase) == -1) // throw new ArgumentOutOfRangeException("Unrecognized catalog!"); // _catalog = value; //} } [Category("Storage")] public string Database { get { return _connection.DataSource; } } [Browsable(false)] public string SqlText { get { return _sql; } set { if (String.Compare(_sql, value, StringComparison.OrdinalIgnoreCase) != 0) { _sql = value; _owner.MakeDirty(); } } } [Browsable(false)] public string OriginalSql { get { return _oldsql; } } public string GetSqlText() { if (String.Compare(_sql, _oldsql, StringComparison.OrdinalIgnoreCase) == 0 && String.Compare(_name, _oldname, StringComparison.OrdinalIgnoreCase) == 0) return null; StringBuilder builder = new StringBuilder(); if (String.IsNullOrEmpty(_oldname) == false) builder.AppendFormat("DROP VIEW [{0}].[{1}];\r\n", Catalog, _oldname); builder.AppendFormat("CREATE VIEW [{0}].[{1}] AS {2};\r\n", Catalog, Name, SqlText); return builder.ToString(); } #region ICustomTypeDescriptor Members AttributeCollection ICustomTypeDescriptor.GetAttributes() { return TypeDescriptor.GetAttributes(GetType()); } string ICustomTypeDescriptor.GetClassName() { return "View Design"; } string ICustomTypeDescriptor.GetComponentName() { return ToString(); } TypeConverter ICustomTypeDescriptor.GetConverter() { return TypeDescriptor.GetConverter(GetType()); } EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() { return TypeDescriptor.GetDefaultEvent(GetType()); } PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() { return TypeDescriptor.GetDefaultProperty(GetType()); } object ICustomTypeDescriptor.GetEditor(Type editorBaseType) { return TypeDescriptor.GetEditor(GetType(), editorBaseType); } EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) { return TypeDescriptor.GetEvents(GetType(), attributes); } EventDescriptorCollection ICustomTypeDescriptor.GetEvents() { return TypeDescriptor.GetEvents(GetType()); } PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) { return TypeDescriptor.GetProperties(GetType(), attributes); } PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() { return TypeDescriptor.GetProperties(GetType()); } object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) { return this; } #endregion #region IHaveConnection Members public DbConnection GetConnection() { return _connection; } #endregion } } |
Changes to SQLite.Designer/Editors/AutoCompleteColumn.cs.
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
..
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
private TableDesignerDoc _owner = null; public override void NotifyCurrentCellDirty(bool dirty) { base.NotifyCurrentCellDirty(dirty); SQLite.Designer.Design.Column col = Rows[CurrentCell.RowIndex].Tag as SQLite.Designer.Design.Column; if (col == null && CurrentRow.IsNewRow == false) { col = new SQLite.Designer.Design.Column(Rows[CurrentCell.RowIndex]); Rows[CurrentCell.RowIndex].Tag = col; base.OnSelectionChanged(new EventArgs()); } if (col != null) col.CellValueChanged(); if (_owner == null) { Control ctl = this; while (ctl.GetType() != typeof(TableDesignerDoc)) { ctl = ctl.Parent; if (ctl == null) break; } if (ctl != null) _owner = ctl as TableDesignerDoc; } if (_owner != null) _owner.RefreshToolbars(); } } public class AutoCompleteColumn : DataGridViewColumn ................................................................................ public override void PrepareEditingControlForEdit(bool selectAll) { inPrepare = true; base.PrepareEditingControlForEdit(selectAll); if (base.Items.Count == 0) { base.Items.Add("integer"); base.Items.Add("smallint"); base.Items.Add("tinyint"); base.Items.Add("bit"); base.Items.Add("varchar(50)"); base.Items.Add("nvarchar(50)"); base.Items.Add("text"); base.Items.Add("ntext"); |
<
<
<
<
<
<
<
<
<
>
>
>
>
>
>
>
>
>
>
>
|
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
..
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
private TableDesignerDoc _owner = null; public override void NotifyCurrentCellDirty(bool dirty) { base.NotifyCurrentCellDirty(dirty); SQLite.Designer.Design.Column col = Rows[CurrentCell.RowIndex].Tag as SQLite.Designer.Design.Column; if (_owner == null) { Control ctl = this; while (ctl.GetType() != typeof(TableDesignerDoc)) { ctl = ctl.Parent; if (ctl == null) break; } if (ctl != null) _owner = ctl as TableDesignerDoc; } if (col == null && CurrentRow.IsNewRow == false) { col = new SQLite.Designer.Design.Column(_owner._table, Rows[CurrentCell.RowIndex]); Rows[CurrentCell.RowIndex].Tag = col; _owner._table.Columns.Insert(CurrentCell.RowIndex, col); base.OnSelectionChanged(new EventArgs()); } if (col != null) col.CellValueChanged(); if (_owner != null) _owner.RefreshToolbars(); } } public class AutoCompleteColumn : DataGridViewColumn ................................................................................ public override void PrepareEditingControlForEdit(bool selectAll) { inPrepare = true; base.PrepareEditingControlForEdit(selectAll); if (base.Items.Count == 0) { base.Items.Add("integer"); base.Items.Add("int"); base.Items.Add("smallint"); base.Items.Add("tinyint"); base.Items.Add("bit"); base.Items.Add("varchar(50)"); base.Items.Add("nvarchar(50)"); base.Items.Add("text"); base.Items.Add("ntext"); |
Changes to SQLite.Designer/Editors/TableDesignerDoc.Designer.cs.
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 .. 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ... 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 ... 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 |
/// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() { this.components = new System.ComponentModel.Container(); System.Windows.Forms.SplitContainer _splitter; System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TableDesignerDoc)); this._dataGrid = new SQLite.Designer.Editors.DbGridView(); this.name = new System.Windows.Forms.DataGridViewTextBoxColumn(); this.type = new SQLite.Designer.Editors.AutoCompleteColumn(); this.isnull = new System.Windows.Forms.DataGridViewCheckBoxColumn(); this._propertyGrid = new System.Windows.Forms.PropertyGrid(); this.autoCompleteColumn1 = new SQLite.Designer.Editors.AutoCompleteColumn(); this._imageList = new System.Windows.Forms.ImageList(this.components); _splitter = new System.Windows.Forms.SplitContainer(); _splitter.Panel1.SuspendLayout(); _splitter.Panel2.SuspendLayout(); _splitter.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this._dataGrid)).BeginInit(); this.SuspendLayout(); // // _splitter // _splitter.BackColor = System.Drawing.SystemColors.Control; _splitter.Dock = System.Windows.Forms.DockStyle.Fill; _splitter.Location = new System.Drawing.Point(0, 0); _splitter.Name = "_splitter"; _splitter.Orientation = System.Windows.Forms.Orientation.Horizontal; // // _splitter.Panel1 // _splitter.Panel1.Controls.Add(this._dataGrid); // // _splitter.Panel2 // _splitter.Panel2.Controls.Add(this._propertyGrid); _splitter.Size = new System.Drawing.Size(436, 401); _splitter.SplitterDistance = 197; _splitter.TabIndex = 0; // // _dataGrid // this._dataGrid.AllowUserToResizeRows = false; this._dataGrid.BackgroundColor = System.Drawing.SystemColors.Window; this._dataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; this._dataGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { this.name, ................................................................................ this.isnull}); this._dataGrid.Dock = System.Windows.Forms.DockStyle.Fill; this._dataGrid.Location = new System.Drawing.Point(0, 0); this._dataGrid.Name = "_dataGrid"; this._dataGrid.RowHeadersWidth = 42; this._dataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.DisableResizing; this._dataGrid.RowTemplate.Height = 23; this._dataGrid.Size = new System.Drawing.Size(436, 197); this._dataGrid.TabIndex = 1; this._dataGrid.CellClick += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellClick); this._dataGrid.RowHeaderMouseClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this._dataGrid_RowHeaderMouseClick); this._dataGrid.CellPainting += new System.Windows.Forms.DataGridViewCellPaintingEventHandler(this._dataGrid_CellPainting); this._dataGrid.UserDeletedRow += new System.Windows.Forms.DataGridViewRowEventHandler(this._dataGrid_UserDeletedRow); this._dataGrid.CellValueChanged += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellValueChanged); this._dataGrid.CellEnter += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellEnter); this._dataGrid.SelectionChanged += new System.EventHandler(this._dataGrid_SelectionChanged); // // name // this.name.Frozen = true; this.name.HeaderText = "Column Name"; this.name.Name = "name"; ................................................................................ this.type.Name = "type"; // // isnull // this.isnull.HeaderText = "Allow Nulls"; this.isnull.Name = "isnull"; // // _propertyGrid // this._propertyGrid.Dock = System.Windows.Forms.DockStyle.Fill; this._propertyGrid.Location = new System.Drawing.Point(0, 0); this._propertyGrid.Name = "_propertyGrid"; this._propertyGrid.Size = new System.Drawing.Size(436, 200); this._propertyGrid.TabIndex = 0; // // autoCompleteColumn1 // this.autoCompleteColumn1.HeaderText = "Data Type"; this.autoCompleteColumn1.Name = "autoCompleteColumn1"; this.autoCompleteColumn1.Resizable = System.Windows.Forms.DataGridViewTriState.True; ................................................................................ // // _imageList // this._imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("_imageList.ImageStream"))); this._imageList.TransparentColor = System.Drawing.Color.Magenta; this._imageList.Images.SetKeyName(0, "PrimaryKey.bmp"); // // TableDesignerDoc // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.BackColor = System.Drawing.SystemColors.Window; this.Controls.Add(_splitter); this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.Name = "TableDesignerDoc"; this.Size = new System.Drawing.Size(436, 401); _splitter.Panel1.ResumeLayout(false); _splitter.Panel2.ResumeLayout(false); _splitter.ResumeLayout(false); ((System.ComponentModel.ISupportInitialize)(this._dataGrid)).EndInit(); this.ResumeLayout(false); } #endregion private DbGridView _dataGrid; private System.Windows.Forms.PropertyGrid _propertyGrid; private AutoCompleteColumn autoCompleteColumn1; private System.Windows.Forms.DataGridViewTextBoxColumn name; private AutoCompleteColumn type; private System.Windows.Forms.DataGridViewCheckBoxColumn isnull; private System.Windows.Forms.ImageList _imageList; } } |
> > > > > > > > | | | | > > > > > > > > > > > > > > > > > > | | | | > < | > > > > > > > > > > > > | > > > > > > > > > > > > > > > | > > > > < > > > | > |
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 ... 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 ... 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 ... 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
/// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() { this.components = new System.ComponentModel.Container(); System.Windows.Forms.SplitContainer _splitter; System.Windows.Forms.SplitContainer splitContainer1; System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TableDesignerDoc)); this._dataGrid = new SQLite.Designer.Editors.DbGridView(); this.name = new System.Windows.Forms.DataGridViewTextBoxColumn(); this.type = new SQLite.Designer.Editors.AutoCompleteColumn(); this.isnull = new System.Windows.Forms.DataGridViewCheckBoxColumn(); this._sqlText = new System.Windows.Forms.RichTextBox(); this._propertyGrid = new System.Windows.Forms.PropertyGrid(); this.autoCompleteColumn1 = new SQLite.Designer.Editors.AutoCompleteColumn(); this._imageList = new System.Windows.Forms.ImageList(this.components); this._timer = new System.Windows.Forms.Timer(this.components); this._pg = new System.Windows.Forms.PropertyGrid(); _splitter = new System.Windows.Forms.SplitContainer(); splitContainer1 = new System.Windows.Forms.SplitContainer(); _splitter.Panel1.SuspendLayout(); _splitter.Panel2.SuspendLayout(); _splitter.SuspendLayout(); splitContainer1.Panel1.SuspendLayout(); splitContainer1.Panel2.SuspendLayout(); splitContainer1.SuspendLayout(); ((System.ComponentModel.ISupportInitialize)(this._dataGrid)).BeginInit(); this.SuspendLayout(); // // _splitter // _splitter.BackColor = System.Drawing.SystemColors.Control; _splitter.Dock = System.Windows.Forms.DockStyle.Fill; _splitter.Location = new System.Drawing.Point(0, 0); _splitter.Name = "_splitter"; _splitter.Orientation = System.Windows.Forms.Orientation.Horizontal; // // _splitter.Panel1 // _splitter.Panel1.Controls.Add(splitContainer1); // // _splitter.Panel2 // _splitter.Panel2.Controls.Add(this._sqlText); _splitter.Size = new System.Drawing.Size(436, 631); _splitter.SplitterDistance = 465; _splitter.TabIndex = 0; // // splitContainer1 // splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; splitContainer1.Location = new System.Drawing.Point(0, 0); splitContainer1.Name = "splitContainer1"; splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal; // // splitContainer1.Panel1 // splitContainer1.Panel1.Controls.Add(this._dataGrid); // // splitContainer1.Panel2 // splitContainer1.Panel2.Controls.Add(this._propertyGrid); splitContainer1.Size = new System.Drawing.Size(436, 465); splitContainer1.SplitterDistance = 215; splitContainer1.TabIndex = 0; // // _dataGrid // this._dataGrid.AllowUserToResizeRows = false; this._dataGrid.BackgroundColor = System.Drawing.SystemColors.Window; this._dataGrid.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; this._dataGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { this.name, ................................................................................ this.isnull}); this._dataGrid.Dock = System.Windows.Forms.DockStyle.Fill; this._dataGrid.Location = new System.Drawing.Point(0, 0); this._dataGrid.Name = "_dataGrid"; this._dataGrid.RowHeadersWidth = 42; this._dataGrid.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.DisableResizing; this._dataGrid.RowTemplate.Height = 23; this._dataGrid.Size = new System.Drawing.Size(436, 215); this._dataGrid.TabIndex = 2; this._dataGrid.CellValueChanged += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellValueChanged); this._dataGrid.UserDeletedRow += new System.Windows.Forms.DataGridViewRowEventHandler(this._dataGrid_UserDeletedRow); this._dataGrid.RowsAdded += new System.Windows.Forms.DataGridViewRowsAddedEventHandler(this._dataGrid_RowsAdded); this._dataGrid.CellPainting += new System.Windows.Forms.DataGridViewCellPaintingEventHandler(this._dataGrid_CellPainting); this._dataGrid.CellClick += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellClick); this._dataGrid.CellEnter += new System.Windows.Forms.DataGridViewCellEventHandler(this._dataGrid_CellEnter); this._dataGrid.RowsRemoved += new System.Windows.Forms.DataGridViewRowsRemovedEventHandler(this._dataGrid_RowsRemoved); this._dataGrid.RowHeaderMouseClick += new System.Windows.Forms.DataGridViewCellMouseEventHandler(this._dataGrid_RowHeaderMouseClick); this._dataGrid.SelectionChanged += new System.EventHandler(this._dataGrid_SelectionChanged); // // name // this.name.Frozen = true; this.name.HeaderText = "Column Name"; this.name.Name = "name"; ................................................................................ this.type.Name = "type"; // // isnull // this.isnull.HeaderText = "Allow Nulls"; this.isnull.Name = "isnull"; // // _sqlText // this._sqlText.Dock = System.Windows.Forms.DockStyle.Fill; this._sqlText.Location = new System.Drawing.Point(0, 0); this._sqlText.Name = "_sqlText"; this._sqlText.ReadOnly = true; this._sqlText.Size = new System.Drawing.Size(436, 162); this._sqlText.TabIndex = 0; this._sqlText.Text = ""; // // _propertyGrid // this._propertyGrid.Dock = System.Windows.Forms.DockStyle.Fill; this._propertyGrid.Location = new System.Drawing.Point(0, 0); this._propertyGrid.Name = "_propertyGrid"; this._propertyGrid.Size = new System.Drawing.Size(436, 246); this._propertyGrid.TabIndex = 0; // // autoCompleteColumn1 // this.autoCompleteColumn1.HeaderText = "Data Type"; this.autoCompleteColumn1.Name = "autoCompleteColumn1"; this.autoCompleteColumn1.Resizable = System.Windows.Forms.DataGridViewTriState.True; ................................................................................ // // _imageList // this._imageList.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("_imageList.ImageStream"))); this._imageList.TransparentColor = System.Drawing.Color.Magenta; this._imageList.Images.SetKeyName(0, "PrimaryKey.bmp"); // // _timer // this._timer.Tick += new System.EventHandler(this._timer_Tick); // // _pg // this._pg.Location = new System.Drawing.Point(0, 0); this._pg.Name = "_pg"; this._pg.PropertySort = System.Windows.Forms.PropertySort.NoSort; this._pg.Size = new System.Drawing.Size(130, 130); this._pg.TabIndex = 1; this._pg.ToolbarVisible = false; this._pg.Visible = false; // // TableDesignerDoc // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.BackColor = System.Drawing.SystemColors.Window; this.Controls.Add(this._pg); this.Controls.Add(_splitter); this.Font = new System.Drawing.Font("Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); this.Name = "TableDesignerDoc"; this.Size = new System.Drawing.Size(436, 631); this.VisibleChanged += new System.EventHandler(this.TableDesignerDoc_VisibleChanged); _splitter.Panel1.ResumeLayout(false); _splitter.Panel2.ResumeLayout(false); _splitter.ResumeLayout(false); splitContainer1.Panel1.ResumeLayout(false); splitContainer1.Panel2.ResumeLayout(false); splitContainer1.ResumeLayout(false); ((System.ComponentModel.ISupportInitialize)(this._dataGrid)).EndInit(); this.ResumeLayout(false); } #endregion private System.Windows.Forms.PropertyGrid _propertyGrid; private AutoCompleteColumn autoCompleteColumn1; private System.Windows.Forms.ImageList _imageList; private DbGridView _dataGrid; private System.Windows.Forms.DataGridViewTextBoxColumn name; private AutoCompleteColumn type; private System.Windows.Forms.DataGridViewCheckBoxColumn isnull; private System.Windows.Forms.RichTextBox _sqlText; private System.Windows.Forms.Timer _timer; private System.Windows.Forms.PropertyGrid _pg; } } |
Changes to SQLite.Designer/Editors/TableDesignerDoc.cs.
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 .. 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 ... 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 ... 173 174 175 176 177 178 179 180 181 182 183 184 185 186 ... 187 188 189 190 191 192 193 194 195 196 197 198 199 200 ... 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 ... 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 ... 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 ... 397 398 399 400 401 402 403 404 405 406 407 408 409 410 ... 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 ... 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 ... 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 ... 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 |
using System.Text; using System.Windows.Forms; using Microsoft.VisualStudio.Shell.Interop; using Microsoft.VisualStudio.OLE.Interop; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data; using SQLite.Designer.Design; public partial class TableDesignerDoc : UserControl, IVsPersistDocData, IVsWindowPane, IOleCommandTarget, ISelectionContainer, IVsWindowPaneCommit, IVsWindowFrameNotify { private static Dictionary<int, string> _editingTables = new Dictionary<int, string>(); internal DataConnection _connection; internal Microsoft.VisualStudio.Data.ServiceProvider _serviceProvider; internal Table _table; public TableDesignerDoc(DataConnection cnn, string tableName) { _connection = cnn; InitializeComponent(); StringBuilder tables = new StringBuilder(); using (DataReader reader = cnn.Command.Execute("SELECT * FROM sqlite_master", 1, null, 30)) { ................................................................................ tableName = String.Format("Table{0}", n); n++; } while (alltables.IndexOf(tableName + ",", StringComparison.OrdinalIgnoreCase) > -1 || _editingTables.ContainsValue(tableName)); _editingTables.Add(GetHashCode(), tableName); } _table = new Table(tableName, _connection.ConnectionSupport.ProviderObject as DbConnection, this); } void SetPropertyWindow() { IVsTrackSelectionEx track = _serviceProvider.GetService(typeof(SVsTrackSelectionEx)) as IVsTrackSelectionEx; if (track != null) { track.OnSelectChange(this); } } public new string Name { get { if (_table != null) return _table.Name; else return base.Name; } set { string caption = "SQLite:" + value; base.Name = value; if (_serviceProvider != null) { IVsWindowFrame frame = _serviceProvider.GetService(typeof(IVsWindowFrame)) as IVsWindowFrame; if (frame != null) { frame.SetProperty((int)__VSFPROPID.VSFPROPID_EditorCaption, value); } } } } //public void NotifyChanges() //{ // if (_serviceProvider == null) return; // // Get a reference to the Running Document Table // IVsRunningDocumentTable runningDocTable = (IVsRunningDocumentTable)_serviceProvider.GetService(typeof(SVsRunningDocumentTable)); // // Lock the document // uint docCookie; // IVsHierarchy hierarchy; // uint itemID; // IntPtr docData; // int hr = runningDocTable.FindAndLockDocument( // (uint)_VSRDTFLAGS.RDT_ReadLock, // base.Name, // out hierarchy, // out itemID, // out docData, // out docCookie // ); // ErrorHandler.ThrowOnFailure(hr); // // Send the notification // hr = runningDocTable.NotifyDocumentChanged(docCookie, (uint)__VSRDTATTRIB.RDTA_DocDataReloaded); // // Unlock the document. // // Note that we have to unlock the document even if the previous call failed. // runningDocTable.UnlockDocument((uint)_VSRDTFLAGS.RDT_ReadLock, docCookie); // // Check ff the call to NotifyDocChanged failed. // ErrorHandler.ThrowOnFailure(hr); //} #region IVsPersistDocData Members int IVsPersistDocData.Close() { return VSConstants.S_OK; } ................................................................................ public int GetGuidEditorType(out Guid pClassID) { return ((IPersistFileFormat)this).GetClassID(out pClassID); } public int IsDocDataDirty(out int pfDirty) { pfDirty = 1; return VSConstants.S_OK; } public int IsDocDataReloadable(out int pfReloadable) { pfReloadable = 0; return VSConstants.S_OK; ................................................................................ } public int SaveDocData(VSSAVEFLAGS dwSave, out string pbstrMkDocumentNew, out int pfSaveCanceled) { pbstrMkDocumentNew = _table.Name; pfSaveCanceled = 0; return VSConstants.S_OK; } public int SetUntitledDocPath(string pszDocDataPath) { return ((IPersistFileFormat)this).InitNew(0); } ................................................................................ #endregion #region IVsWindowPane Members public int ClosePane() { this.Dispose(true); return VSConstants.S_OK; } public int CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr hwnd) { Win32Methods.SetParent(Handle, hwndParent); ................................................................................ public int TranslateAccelerator(Microsoft.VisualStudio.OLE.Interop.MSG[] lpmsg) { return VSConstants.S_FALSE; } #endregion #region IOleCommandTarget Members public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); } public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText) { System.Diagnostics.Debug.WriteLine(pguidCmdGroup.ToString()); if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)prgCmds[0].cmdID) { case VSConstants.VSStd97CmdID.PrimaryKey: case VSConstants.VSStd97CmdID.GenerateChangeScript: prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); System.Diagnostics.Debug.Write("."); break; default: return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); } return VSConstants.S_OK; } if (pguidCmdGroup == SQLiteCommandHandler.guidDavinci) { switch (prgCmds[0].cmdID) { case (uint)VSConstants.VSStd97CmdID.ManageRelationships: case (uint)VSConstants.VSStd97CmdID.ManageIndexes: case (uint)VSConstants.VSStd97CmdID.ManageConstraints: //case 10: // Table View -> Custom //case 14: // Table View -> Modify Custom //case 33: // Database Diagram -> Add Table //case 1: // Database Diagram -> Add Related Tables //case 12: // Database Diagram -> Delete From Database //case 51: // Database Diagram -> Remove From Diagram //case 13: // Database Diagram -> Autosize Selected Tables ................................................................................ { apUnkObjects[0] = _table; return VSConstants.S_OK; } int ISelectionContainer.SelectObjects(uint cSelect, object[] apUnkSelect, uint dwFlags) { apUnkSelect[0] = _table; return VSConstants.S_OK; } #endregion #region IVsWindowPaneCommit Members ................................................................................ return VSConstants.S_OK; } int IVsWindowFrameNotify.OnMove() { return VSConstants.S_OK; } int IVsWindowFrameNotify.OnShow(int fShow) { switch ((__FRAMESHOW)fShow) { case __FRAMESHOW.FRAMESHOW_TabActivated: case __FRAMESHOW.FRAMESHOW_WinShown: SetPropertyWindow(); break; } return VSConstants.S_OK; } int IVsWindowFrameNotify.OnSize() { ................................................................................ } private void _dataGrid_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) { _dataGrid.EndEdit(); if (e.Button == MouseButtons.Right) { IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { Guid guid; POINTS[] p = new POINTS[1]; int ret; ................................................................................ ret = shell.ShowContextMenu(0, ref guid, 259, p, this); } } } private void _dataGrid_CellClick(object sender, DataGridViewCellEventArgs e) { if (e.ColumnIndex == -1 && e.RowIndex == -1) { _dataGrid.EndEdit(); } _dataGrid_SelectionChanged(sender, e); } private void _dataGrid_CellPainting(object sender, DataGridViewCellPaintingEventArgs e) { if (e.ColumnIndex > -1 || e.RowIndex < 0) return; Column col = _dataGrid.Rows[e.RowIndex].Tag as Column; if (col == null) return; if (col.PrimaryKey.Enabled == true) { e.Paint(e.ClipBounds, DataGridViewPaintParts.All); _imageList.Draw(e.Graphics, e.CellBounds.Left, e.CellBounds.Top + ((e.CellBounds.Bottom - e.CellBounds.Top) - _imageList.ImageSize.Height) / 2, 0); e.Handled = true; } } private void _dataGrid_SelectionChanged(object sender, EventArgs e) { List<object> items = new List<object>(); for (int n = 0; n < _dataGrid.Rows.Count; n++) { if (_dataGrid.Rows[n].Selected || (_dataGrid.CurrentCell.RowIndex == n && _dataGrid.IsCurrentCellInEditMode == true)) { if (_dataGrid.Rows[n].Tag != null) ................................................................................ } } object[] objs = new object[items.Count]; items.CopyTo(objs); _propertyGrid.SelectedObjects = objs; } private void _dataGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e) { _propertyGrid.SelectedObjects = _propertyGrid.SelectedObjects; } private void _dataGrid_UserDeletedRow(object sender, DataGridViewRowEventArgs e) { _dataGrid_SelectionChanged(sender, e); } } internal class FakeHierarchy : IVsUIHierarchy, IVsPersistHierarchyItem2 { TableDesignerDoc _control; IVsUIHierarchy _owner; Dictionary<uint, IVsHierarchyEvents> _events = new Dictionary<uint, IVsHierarchyEvents>(); internal FakeHierarchy(TableDesignerDoc control, IVsUIHierarchy owner) { _control = control; _owner = owner; } #region IVsUIHierarchy Members ................................................................................ int IVsUIHierarchy.ExecCommand(uint itemid, ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return VSConstants.E_NOTIMPL; } int IVsUIHierarchy.GetCanonicalName(uint itemid, out string pbstrName) { pbstrName = _control._table.Name; return VSConstants.S_OK; } int IVsUIHierarchy.GetGuidProperty(uint itemid, int propid, out Guid pguid) { return _owner.GetGuidProperty(itemid, propid, out pguid); } ................................................................................ pvar = true; break; case __VSHPROPID.VSHPROPID_CanBuildFromMemory: pvar = true; break; case __VSHPROPID.VSHPROPID_Caption: case __VSHPROPID.VSHPROPID_SaveName: pvar = _control._table.Name; break; case __VSHPROPID.VSHPROPID_IsHiddenItem: pvar = true; break; case __VSHPROPID.VSHPROPID_IsNewUnsavedItem: pvar = true; break; |
> | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > < | | < > | > > | | | | | | | | | | | | | | | | < < > > | > > > | | | > | | < > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > < < > > > > > | | < | | < > > > > > > > > > > > > > > > > > > > > > > > > < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | > > > > > > > > > > > > > > > > > > > > | > > | > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | | | |
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 .. 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 ... 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 ... 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 ... 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 ... 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 ... 562 563 564 565 566 567 568 569 570 571 572 573 574 575 ... 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 ... 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 ... 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 ... 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 ... 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 ... 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 |
using System.Text; using System.Windows.Forms; using Microsoft.VisualStudio.Shell.Interop; using Microsoft.VisualStudio.OLE.Interop; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data; using SQLite.Designer.Design; using System.ComponentModel.Design; public partial class TableDesignerDoc : DesignerDocBase, IVsPersistDocData, IVsWindowPane, IOleCommandTarget, ISelectionContainer, IVsWindowPaneCommit, IVsWindowFrameNotify { private static Dictionary<int, string> _editingTables = new Dictionary<int, string>(); internal DataConnection _connection; internal Microsoft.VisualStudio.Data.ServiceProvider _serviceProvider; internal Table _table; internal bool _dirty; internal bool _init = false; private bool _warned = false; public TableDesignerDoc(DataConnection cnn, string tableName) { _connection = cnn; _init = true; InitializeComponent(); StringBuilder tables = new StringBuilder(); using (DataReader reader = cnn.Command.Execute("SELECT * FROM sqlite_master", 1, null, 30)) { ................................................................................ tableName = String.Format("Table{0}", n); n++; } while (alltables.IndexOf(tableName + ",", StringComparison.OrdinalIgnoreCase) > -1 || _editingTables.ContainsValue(tableName)); _editingTables.Add(GetHashCode(), tableName); } _table = new Table(tableName, _connection.ConnectionSupport.ProviderObject as DbConnection, this); foreach(Column c in _table.Columns) { n = _dataGrid.Rows.Add(); _dataGrid.Rows[n].Tag = c; c.Parent = _dataGrid.Rows[n]; } _init = false; if (_dataGrid.Rows.Count > 0) { _dataGrid.EndEdit(); _sqlText.Text = _table.OriginalSql; } } public override string CanonicalName { get { return _table.Name; } } void SetPropertyWindow() { IVsTrackSelectionEx track = _serviceProvider.GetService(typeof(SVsTrackSelectionEx)) as IVsTrackSelectionEx; if (track != null) { track.OnSelectChange(this); } } public string Caption { get { string catalog = "main"; if (_table != null) catalog = _table.Catalog; return String.Format("{0}.{1} Table (SQLite [{2}])", catalog, base.Name, ((DbConnection)_connection.ConnectionSupport.ProviderObject).DataSource); } } public new string Name { get { if (_table != null) return _table.Name; else return base.Name; } set { base.Name = value; if (_serviceProvider != null) { IVsWindowFrame frame = _serviceProvider.GetService(typeof(IVsWindowFrame)) as IVsWindowFrame; if (frame != null) { frame.SetProperty((int)__VSFPROPID.VSFPROPID_EditorCaption, Caption); } } } } public void NotifyChanges() { if (_serviceProvider == null) return; _sqlText.Text = _table.GetSql(); // Get a reference to the Running Document Table IVsRunningDocumentTable runningDocTable = (IVsRunningDocumentTable)_serviceProvider.GetService(typeof(SVsRunningDocumentTable)); // Lock the document uint docCookie; IVsHierarchy hierarchy; uint itemID; IntPtr docData; int hr = runningDocTable.FindAndLockDocument( (uint)_VSRDTFLAGS.RDT_ReadLock, base.Name, out hierarchy, out itemID, out docData, out docCookie ); ErrorHandler.ThrowOnFailure(hr); IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { shell.UpdateDocDataIsDirtyFeedback(docCookie, (_dirty == true) ? 1 : 0); } // Unlock the document. // Note that we have to unlock the document even if the previous call failed. runningDocTable.UnlockDocument((uint)_VSRDTFLAGS.RDT_ReadLock, docCookie); // Check ff the call to NotifyDocChanged failed. //ErrorHandler.ThrowOnFailure(hr); } #region IVsPersistDocData Members int IVsPersistDocData.Close() { return VSConstants.S_OK; } ................................................................................ public int GetGuidEditorType(out Guid pClassID) { return ((IPersistFileFormat)this).GetClassID(out pClassID); } public int IsDocDataDirty(out int pfDirty) { pfDirty = _dirty == true ? 1 : 0; return VSConstants.S_OK; } public int IsDocDataReloadable(out int pfReloadable) { pfReloadable = 0; return VSConstants.S_OK; ................................................................................ } public int SaveDocData(VSSAVEFLAGS dwSave, out string pbstrMkDocumentNew, out int pfSaveCanceled) { pbstrMkDocumentNew = _table.Name; pfSaveCanceled = 0; if (String.IsNullOrEmpty(_table.OriginalSql) == true) { using (TableNameDialog dlg = new TableNameDialog("Table", _table.Name)) { if (dlg.ShowDialog(this) == DialogResult.Cancel) { pfSaveCanceled = 1; return VSConstants.S_OK; } _table.Name = dlg.TableName; } } _init = true; for (int n = 0; n < _table.Columns.Count; n++) { Column c = _table.Columns[n]; if (String.IsNullOrEmpty(c.ColumnName) == true) { _dataGrid.Rows.Remove(c.Parent); _table.Columns.Remove(c); n--; continue; } } for (int n = 0; n < _dataGrid.Rows.Count; n++) { if ((_dataGrid.Rows[n].Tag is Column) == false) { try { _dataGrid.Rows.RemoveAt(n); } catch { if (n == _dataGrid.Rows.Count - 1) break; } n--; } } _init = false; using (DbTransaction trans = _table.GetConnection().BeginTransaction()) { try { using (DbCommand cmd = _table.GetConnection().CreateCommand()) { cmd.CommandText = _table.GetSql(); cmd.ExecuteNonQuery(); } trans.Commit(); } catch (Exception) { trans.Rollback(); throw; } } _dirty = false; _table.Committed(); NotifyChanges(); _sqlText.Text = _table.OriginalSql; return VSConstants.S_OK; } public int SetUntitledDocPath(string pszDocDataPath) { return ((IPersistFileFormat)this).InitNew(0); } ................................................................................ #endregion #region IVsWindowPane Members public int ClosePane() { if (_serviceProvider != null) { EnvDTE.DTE dte = (EnvDTE.DTE)_serviceProvider.GetService(typeof(EnvDTE.DTE)); //Show toolbar if (dte != null) { Microsoft.VisualStudio.CommandBars.CommandBars commandBars = (Microsoft.VisualStudio.CommandBars.CommandBars)dte.CommandBars; Microsoft.VisualStudio.CommandBars.CommandBar bar = commandBars["Table Designer"]; bar.Visible = false; } } this.Dispose(true); return VSConstants.S_OK; } public int CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr hwnd) { Win32Methods.SetParent(Handle, hwndParent); ................................................................................ public int TranslateAccelerator(Microsoft.VisualStudio.OLE.Interop.MSG[] lpmsg) { return VSConstants.S_FALSE; } #endregion public void MakeDirty() { _dirty = true; NotifyChanges(); } private bool IsPkSelected() { bool newVal = false; foreach (Column c in _propertyGrid.SelectedObjects) { foreach (IndexColumn ic in _table.PrimaryKey.Columns) { if (String.Compare(c.ColumnName, ic.Column, StringComparison.OrdinalIgnoreCase) == 0) { newVal = true; break; } } } return newVal; } #region IOleCommandTarget Members public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.PrimaryKey: bool newVal = IsPkSelected(); if (newVal == false) { _table.PrimaryKey.Columns.Clear(); foreach (Column c in _propertyGrid.SelectedObjects) { IndexColumn newcol = new IndexColumn(_table.PrimaryKey, null); newcol.Column = c.ColumnName; _table.PrimaryKey.Columns.Add(newcol); } } else { foreach (Column c in _propertyGrid.SelectedObjects) { foreach (IndexColumn ic in _table.PrimaryKey.Columns) { if (String.Compare(c.ColumnName, ic.Column, StringComparison.OrdinalIgnoreCase) == 0) { _table.PrimaryKey.Columns.Remove(ic); break; } } } } _dataGrid_SelectionChanged(this, EventArgs.Empty); _dataGrid.Invalidate(); MakeDirty(); return VSConstants.S_OK; } } else if (pguidCmdGroup == SQLiteCommandHandler.guidDavinci) { switch ((VSConstants.VSStd97CmdID)nCmdID) { case VSConstants.VSStd97CmdID.ManageIndexes: IndexHolder holder = new IndexHolder(_table.Indexes, _table.ForeignKeys); _pg.SelectedObject = holder; _pg.SelectedGridItem = _pg.SelectedGridItem.Parent.GridItems[0]; IndexEditor ed = new IndexEditor(_table); ed.EditValue((ITypeDescriptorContext)_pg.SelectedGridItem, (System.IServiceProvider)_pg.SelectedGridItem, _pg.SelectedGridItem.Value); return VSConstants.S_OK; case VSConstants.VSStd97CmdID.ManageRelationships: holder = new IndexHolder(_table.Indexes, _table.ForeignKeys); _pg.SelectedObject = holder; _pg.SelectedGridItem = _pg.SelectedGridItem.Parent.GridItems[1]; ForeignKeyEditor fed = new ForeignKeyEditor(_table); fed.EditValue((ITypeDescriptorContext)_pg.SelectedGridItem, (System.IServiceProvider)_pg.SelectedGridItem, _pg.SelectedGridItem.Value); return VSConstants.S_OK; case VSConstants.VSStd97CmdID.AlignRight: // Insert Column _dataGrid.Rows.Insert(_dataGrid.SelectedRows[0].Index, 1); return VSConstants.S_OK; case VSConstants.VSStd97CmdID.AlignToGrid: // Delete Column while (_dataGrid.SelectedRows.Count > 0) { try { DataGridViewRow row = _dataGrid.SelectedRows[0]; Column c = row.Tag as Column; row.Selected = false; if (c != null) _table.Columns.Remove(c); _dataGrid.Rows.Remove(row); } catch { } } return VSConstants.S_OK; } } return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); } public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText) { if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) { switch ((VSConstants.VSStd97CmdID)prgCmds[0].cmdID) { case VSConstants.VSStd97CmdID.PrimaryKey: prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); if (IsPkSelected() == true) prgCmds[0].cmdf |= (uint)(OLECMDF.OLECMDF_LATCHED); break; //case VSConstants.VSStd97CmdID.GenerateChangeScript: // prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); // break; default: return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); } return VSConstants.S_OK; } if (pguidCmdGroup == SQLiteCommandHandler.guidDavinci) { switch (prgCmds[0].cmdID) { case (uint)VSConstants.VSStd97CmdID.ManageRelationships: case (uint)VSConstants.VSStd97CmdID.ManageIndexes: //case (uint)VSConstants.VSStd97CmdID.ManageConstraints: //case 10: // Table View -> Custom //case 14: // Table View -> Modify Custom //case 33: // Database Diagram -> Add Table //case 1: // Database Diagram -> Add Related Tables //case 12: // Database Diagram -> Delete From Database //case 51: // Database Diagram -> Remove From Diagram //case 13: // Database Diagram -> Autosize Selected Tables ................................................................................ { apUnkObjects[0] = _table; return VSConstants.S_OK; } int ISelectionContainer.SelectObjects(uint cSelect, object[] apUnkSelect, uint dwFlags) { return VSConstants.S_OK; } #endregion #region IVsWindowPaneCommit Members ................................................................................ return VSConstants.S_OK; } int IVsWindowFrameNotify.OnMove() { return VSConstants.S_OK; } private void _timer_Tick(object sender, EventArgs e) { _timer.Enabled = false; if (_serviceProvider != null) { EnvDTE.DTE dte = (EnvDTE.DTE)_serviceProvider.GetService(typeof(EnvDTE.DTE)); //Show toolbar if (dte != null) { Microsoft.VisualStudio.CommandBars.CommandBars commandBars = (Microsoft.VisualStudio.CommandBars.CommandBars)dte.CommandBars; Microsoft.VisualStudio.CommandBars.CommandBar bar = commandBars["Table Designer"]; bar.Visible = true; } } if (_warned == false) { _warned = true; if (_table.HasCheck == true) MessageBox.Show(this, "This table has CHECK constraints that could not be parsed. Before making any changes to this table, make sure you note the constraints in the SQL window first", "Parser Error"); } } int IVsWindowFrameNotify.OnShow(int fShow) { switch ((__FRAMESHOW)fShow) { case __FRAMESHOW.FRAMESHOW_WinShown: SetPropertyWindow(); _timer.Enabled = true; break; case __FRAMESHOW.FRAMESHOW_WinHidden: break; } return VSConstants.S_OK; } int IVsWindowFrameNotify.OnSize() { ................................................................................ } private void _dataGrid_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e) { _dataGrid.EndEdit(); if (e.Button == MouseButtons.Right) { if (_dataGrid.Rows[e.RowIndex].Selected == false) { switch (Control.ModifierKeys) { case Keys.Control: _dataGrid.Rows[e.RowIndex].Selected = true; break; case Keys.Shift: int min = Math.Min(_dataGrid.CurrentRow.Index, e.RowIndex); int max = Math.Max(_dataGrid.CurrentRow.Index, e.RowIndex); for (int n = 0; n < _dataGrid.Rows.Count; n++) { _dataGrid.Rows[n].Selected = (_dataGrid.Rows[n].Index <= min || _dataGrid.Rows[n].Index <= max); } break; default: for (int n = 0; n < _dataGrid.Rows.Count; n++) { _dataGrid.Rows[n].Selected = (e.RowIndex == n); } break; } } IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { Guid guid; POINTS[] p = new POINTS[1]; int ret; ................................................................................ ret = shell.ShowContextMenu(0, ref guid, 259, p, this); } } } private void _dataGrid_CellClick(object sender, DataGridViewCellEventArgs e) { if (_init == true) return; if (e.ColumnIndex == -1 && e.RowIndex == -1) { _dataGrid.EndEdit(); } _dataGrid_SelectionChanged(sender, e); } private void _dataGrid_CellPainting(object sender, DataGridViewCellPaintingEventArgs e) { if (_init == true) return; if (e.ColumnIndex > -1 || e.RowIndex < 0) return; Column col = _dataGrid.Rows[e.RowIndex].Tag as Column; if (col == null) return; bool ispk = false; foreach (IndexColumn ic in _table.PrimaryKey.Columns) { if (String.Compare(ic.Column, col.ColumnName, StringComparison.OrdinalIgnoreCase) == 0) { ispk = true; break; } } if (ispk == true) { e.Paint(e.ClipBounds, DataGridViewPaintParts.All); _imageList.Draw(e.Graphics, e.CellBounds.Left, e.CellBounds.Top + ((e.CellBounds.Bottom - e.CellBounds.Top) - _imageList.ImageSize.Height) / 2, 0); e.Handled = true; } } private void _dataGrid_SelectionChanged(object sender, EventArgs e) { if (_init == true) return; List<object> items = new List<object>(); for (int n = 0; n < _dataGrid.Rows.Count; n++) { if (_dataGrid.Rows[n].Selected || (_dataGrid.CurrentCell.RowIndex == n && _dataGrid.IsCurrentCellInEditMode == true)) { if (_dataGrid.Rows[n].Tag != null) ................................................................................ } } object[] objs = new object[items.Count]; items.CopyTo(objs); _propertyGrid.SelectedObjects = objs; IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { shell.UpdateCommandUI(0); } } private void _dataGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e) { if (_init == true) return; if (e.RowIndex > -1) { MakeDirty(); _propertyGrid.SelectedObjects = _propertyGrid.SelectedObjects; } } private void _dataGrid_UserDeletedRow(object sender, DataGridViewRowEventArgs e) { if (_init == true) return; _dataGrid_SelectionChanged(sender, e); } private void _dataGrid_RowsAdded(object sender, DataGridViewRowsAddedEventArgs e) { if (_init == true) return; MakeDirty(); } private void _dataGrid_RowsRemoved(object sender, DataGridViewRowsRemovedEventArgs e) { if (_init == true) return; MakeDirty(); } private void TableDesignerDoc_VisibleChanged(object sender, EventArgs e) { } } internal class IndexHolder { private List<Index> _indexes; private List<ForeignKey> _fkeys; internal IndexHolder(List<Index> idx, List<ForeignKey> fk) { _indexes = idx; _fkeys = fk; } public List<Index> Indexes { get { return _indexes; } } public List<ForeignKey> ForeignKeys { get { return _fkeys; } } } public class DesignerDocBase : UserControl { public virtual string CanonicalName { get { return null; } } } internal class FakeHierarchy : IVsUIHierarchy, IVsPersistHierarchyItem2 { DesignerDocBase _control; IVsUIHierarchy _owner; Dictionary<uint, IVsHierarchyEvents> _events = new Dictionary<uint, IVsHierarchyEvents>(); internal FakeHierarchy(DesignerDocBase control, IVsUIHierarchy owner) { _control = control; _owner = owner; } #region IVsUIHierarchy Members ................................................................................ int IVsUIHierarchy.ExecCommand(uint itemid, ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { return VSConstants.E_NOTIMPL; } int IVsUIHierarchy.GetCanonicalName(uint itemid, out string pbstrName) { pbstrName = _control.CanonicalName; return VSConstants.S_OK; } int IVsUIHierarchy.GetGuidProperty(uint itemid, int propid, out Guid pguid) { return _owner.GetGuidProperty(itemid, propid, out pguid); } ................................................................................ pvar = true; break; case __VSHPROPID.VSHPROPID_CanBuildFromMemory: pvar = true; break; case __VSHPROPID.VSHPROPID_Caption: case __VSHPROPID.VSHPROPID_SaveName: pvar = _control.CanonicalName; break; case __VSHPROPID.VSHPROPID_IsHiddenItem: pvar = true; break; case __VSHPROPID.VSHPROPID_IsNewUnsavedItem: pvar = true; break; |
Changes to SQLite.Designer/Editors/TableDesignerDoc.resx.
115
116
117
118
119
120
121
122
123
124
125
126
127
128
...
146
147
148
149
150
151
152
153
|
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<metadata name="_splitter.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>False</value>
</metadata>
<metadata name="name.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>True</value>
</metadata>
<metadata name="type.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>True</value>
</metadata>
................................................................................
Ae8BLgFhAXsBjQHlAfEBrgH4Af8BBQFCAV//AMwAAUcBkAGpAZ8B9QH/Aa4B+gH/AZIB5wHwAbEB+gH/
AYoB6QH1AQQBSgFo/wDMAAHTAdsB3wFpAbYBygFSAZwBswE5AYABmgElAW8BkAEZAWoBjgHWAd0B4f8A
/wD/AP8A/wD/AP8AGwABQgFNAT4HAAE+AwABKAMAAaADAAEQAwABAQEAAQEFAAFAAQEWAAP/AQAF/w8A
Bf8PAAP/Af4BPw8AA/8B/gEfDwAD/wH+AR8PAAP/Af4BHw8AA/8B/gEfDwAD/wH8AR8PAAP/AfgBDw8A
A/8B+AEPDwAD/wH4AQ8PAAP/AfgBDw8AA/8B+AEPDwAF/w8ABf8PAAX/DwAL
</value>
</data>
</root>
|
>
>
>
>
>
>
|
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
...
149
150
151
152
153
154
155
156
157
158
159
|
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <resheader name="writer"> <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <metadata name="_splitter.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>False</value> </metadata> <metadata name="splitContainer1.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>False</value> </metadata> <metadata name="name.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>True</value> </metadata> <metadata name="type.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>True</value> </metadata> ................................................................................ Ae8BLgFhAXsBjQHlAfEBrgH4Af8BBQFCAV//AMwAAUcBkAGpAZ8B9QH/Aa4B+gH/AZIB5wHwAbEB+gH/ AYoB6QH1AQQBSgFo/wDMAAHTAdsB3wFpAbYBygFSAZwBswE5AYABmgElAW8BkAEZAWoBjgHWAd0B4f8A /wD/AP8A/wD/AP8AGwABQgFNAT4HAAE+AwABKAMAAaADAAEQAwABAQEAAQEFAAFAAQEWAAP/AQAF/w8A Bf8PAAP/Af4BPw8AA/8B/gEfDwAD/wH+AR8PAAP/Af4BHw8AA/8B/gEfDwAD/wH8AR8PAAP/AfgBDw8A A/8B+AEPDwAD/wH4AQ8PAAP/AfgBDw8AA/8B+AEPDwAF/w8ABf8PAAX/DwAL </value> </data> <metadata name="_timer.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <value>126, 17</value> </metadata> </root> |
Added SQLite.Designer/Editors/ViewDesignerDoc.Designer.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
namespace SQLite.Designer.Editors { partial class ViewDesignerDoc { /// <summary> /// Required designer variable. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } _editingTables.Remove(GetHashCode()); base.Dispose(disposing); } #region Component Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() { this.components = new System.ComponentModel.Container(); this._timer = new System.Windows.Forms.Timer(this.components); this._check = new System.Windows.Forms.Timer(this.components); this.SuspendLayout(); // // _timer // this._timer.Tick += new System.EventHandler(this._timer_Tick); // // _check // this._check.Interval = 200; this._check.Tick += new System.EventHandler(this._check_Tick); // // ViewDesignerDoc // this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.Name = "ViewDesignerDoc"; this.Size = new System.Drawing.Size(553, 407); this.ResumeLayout(false); } #endregion private System.Windows.Forms.Timer _timer; private System.Windows.Forms.Timer _check; } } |
Added SQLite.Designer/Editors/ViewDesignerDoc.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 |
namespace SQLite.Designer.Editors { using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Data.Common; using System.Drawing; using System.Text; using System.Windows.Forms; using Microsoft.VisualStudio.Shell.Interop; using Microsoft.VisualStudio.OLE.Interop; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data; using SQLite.Designer.Design; using System.ComponentModel.Design; using System.Runtime.InteropServices; public partial class ViewDesignerDoc : DesignerDocBase, IVsPersistDocData, IVsWindowPane, IOleCommandTarget, ISelectionContainer, IVsWindowPaneCommit, IVsWindowFrameNotify { private static Dictionary<int, string> _editingTables = new Dictionary<int, string>(); private bool _qdinit = false; private bool _init = false; internal DataConnection _connection; internal Microsoft.VisualStudio.Data.ServiceProvider _serviceProvider; internal bool _dirty = false; internal UserControl _queryDesigner; internal Type _typeQB; internal SQLite.Designer.Design.View _view; internal IOleCommandTarget _qbole; internal IOleInPlaceActiveObject _qbbase; private IntPtr _qbsql; public delegate bool EnumWindowsCallback(IntPtr hwnd, IntPtr lParam); [DllImport("user32.Dll")] public static extern bool EnumChildWindows(IntPtr parentHandle, EnumWindowsCallback callback, IntPtr lParam); [DllImport("user32.dll", CharSet = CharSet.Auto)] static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount); [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount); [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] static extern int GetWindowTextLength(IntPtr hWnd); public ViewDesignerDoc(DataConnection cnn, string viewName) { _connection = cnn; InitializeComponent(); _init = true; try { _typeQB = SQLiteDataAdapterToolboxItem._vsdesigner.GetType("Microsoft.VSDesigner.Data.Design.QueryBuilderControl"); if (_typeQB != null) { _queryDesigner = Activator.CreateInstance(_typeQB) as UserControl; _typeQB.InvokeMember("Provider", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.SetProperty | System.Reflection.BindingFlags.NonPublic, null, _queryDesigner, new object[] { "System.Data.SQLite" }); _typeQB.InvokeMember("ConnectionString", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.SetProperty | System.Reflection.BindingFlags.NonPublic, null, _queryDesigner, new object[] { cnn.ConnectionSupport.ConnectionString }); _typeQB.InvokeMember("EnableMorphing", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.SetProperty | System.Reflection.BindingFlags.NonPublic, null, _queryDesigner, new object[] { false }); Controls.Add(_queryDesigner); _queryDesigner.Dock = DockStyle.Fill; _queryDesigner.Visible = true; } StringBuilder tables = new StringBuilder(); using (DataReader reader = cnn.Command.Execute("SELECT * FROM sqlite_master", 1, null, 30)) { while (reader.Read()) { tables.Append(reader.GetItem(2).ToString()); tables.Append(","); } } int n = 1; if (String.IsNullOrEmpty(viewName)) { string alltables = tables.ToString(); do { viewName = String.Format("View{0}", n); n++; } while (alltables.IndexOf(viewName + ",", StringComparison.OrdinalIgnoreCase) > -1 || _editingTables.ContainsValue(viewName)); _editingTables.Add(GetHashCode(), viewName); } _view = new SQLite.Designer.Design.View(viewName, cnn.ConnectionSupport.ProviderObject as DbConnection, this); } finally { _init = false; } } private string GetRichText() { if (_qbsql != IntPtr.Zero) { int len = GetWindowTextLength(_qbsql); StringBuilder builder = new StringBuilder(len + 1); GetWindowText(_qbsql, builder, builder.Capacity); return builder.ToString(); } return String.Empty; } void SetPropertyWindow() { IVsTrackSelectionEx track = _serviceProvider.GetService(typeof(SVsTrackSelectionEx)) as IVsTrackSelectionEx; if (track != null) { track.OnSelectChange(this); } } public string Caption { get { string catalog = "main"; if (_view != null) catalog = _view.Catalog; return String.Format("{0}.{1} View (SQLite [{2}])", catalog, base.Name, ((DbConnection)_connection.ConnectionSupport.ProviderObject).DataSource); } } public override string CanonicalName { get { return _view.Name; } } public new string Name { get { if (_view != null) return _view.Name; else return base.Name; } set { base.Name = value; if (_serviceProvider != null) { IVsWindowFrame frame = _serviceProvider.GetService(typeof(IVsWindowFrame)) as IVsWindowFrame; if (frame != null) { frame.SetProperty((int)__VSFPROPID.VSFPROPID_EditorCaption, Caption); } } } } public void NotifyChanges() { if (_serviceProvider == null) return; //_sqlText.Text = _table.GetSql(); // Get a reference to the Running Document Table IVsRunningDocumentTable runningDocTable = (IVsRunningDocumentTable)_serviceProvider.GetService(typeof(SVsRunningDocumentTable)); // Lock the document uint docCookie; IVsHierarchy hierarchy; uint itemID; IntPtr docData; int hr = runningDocTable.FindAndLockDocument( (uint)_VSRDTFLAGS.RDT_ReadLock, base.Name, out hierarchy, out itemID, out docData, out docCookie ); ErrorHandler.ThrowOnFailure(hr); IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { shell.UpdateDocDataIsDirtyFeedback(docCookie, (_dirty == true) ? 1 : 0); } // Unlock the document. // Note that we have to unlock the document even if the previous call failed. runningDocTable.UnlockDocument((uint)_VSRDTFLAGS.RDT_ReadLock, docCookie); // Check ff the call to NotifyDocChanged failed. //ErrorHandler.ThrowOnFailure(hr); } #region IVsPersistDocData Members int IVsPersistDocData.Close() { return VSConstants.S_OK; } public int GetGuidEditorType(out Guid pClassID) { return ((IPersistFileFormat)this).GetClassID(out pClassID); } public int IsDocDataDirty(out int pfDirty) { pfDirty = _dirty == true ? 1 : 0; return VSConstants.S_OK; } public int IsDocDataReloadable(out int pfReloadable) { pfReloadable = 0; return VSConstants.S_OK; } public int LoadDocData(string pszMkDocument) { return ((IPersistFileFormat)this).Load(pszMkDocument, 0, 0); } public int OnRegisterDocData(uint docCookie, IVsHierarchy pHierNew, uint itemidNew) { return VSConstants.S_OK; } public int ReloadDocData(uint grfFlags) { return VSConstants.E_NOTIMPL; } public int RenameDocData(uint grfAttribs, IVsHierarchy pHierNew, uint itemidNew, string pszMkDocumentNew) { return VSConstants.E_NOTIMPL; } public int SaveDocData(VSSAVEFLAGS dwSave, out string pbstrMkDocumentNew, out int pfSaveCanceled) { pbstrMkDocumentNew = null; // _view.Name; pfSaveCanceled = 0; if (String.IsNullOrEmpty(_view.OriginalSql) == true) { using (TableNameDialog dlg = new TableNameDialog("View", _view.Name)) { if (dlg.ShowDialog(this) == DialogResult.Cancel) { pfSaveCanceled = 1; return VSConstants.S_OK; } _view.Name = dlg.TableName; } } //_init = true; //for (int n = 0; n < _table.Columns.Count; n++) //{ // Column c = _table.Columns[n]; // if (String.IsNullOrEmpty(c.ColumnName) == true) // { // _dataGrid.Rows.Remove(c.Parent); // _table.Columns.Remove(c); // n--; // continue; // } //} //for (int n = 0; n < _dataGrid.Rows.Count; n++) //{ // if ((_dataGrid.Rows[n].Tag is Column) == false) // { // try // { // _dataGrid.Rows.RemoveAt(n); // } // catch // { // } // n--; // } //} //_init = false; string query = _typeQB.InvokeMember("SqlText", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty, null, _queryDesigner, null) as string; _view.SqlText = query; query = _view.GetSqlText(); if (String.IsNullOrEmpty(query) == false) { using (DbTransaction trans = _view.GetConnection().BeginTransaction()) { try { using (DbCommand cmd = _view.GetConnection().CreateCommand()) { cmd.CommandText = query; cmd.ExecuteNonQuery(); } trans.Commit(); } catch (Exception) { trans.Rollback(); throw; } } } _dirty = false; _view.Committed(); NotifyChanges(); return VSConstants.S_OK; } public int SetUntitledDocPath(string pszDocDataPath) { return ((IPersistFileFormat)this).InitNew(0); } #endregion #region IVsWindowPane Members public int ClosePane() { if (_serviceProvider != null) { EnvDTE.DTE dte = (EnvDTE.DTE)_serviceProvider.GetService(typeof(EnvDTE.DTE)); //Show toolbar if (dte != null) { Microsoft.VisualStudio.CommandBars.CommandBars commandBars = (Microsoft.VisualStudio.CommandBars.CommandBars)dte.CommandBars; Microsoft.VisualStudio.CommandBars.CommandBar bar = commandBars["View Designer"]; bar.Visible = false; } } this.Dispose(true); return VSConstants.S_OK; } public int CreatePaneWindow(IntPtr hwndParent, int x, int y, int cx, int cy, out IntPtr hwnd) { Win32Methods.SetParent(Handle, hwndParent); hwnd = Handle; Size = new System.Drawing.Size(cx - x, cy - y); return VSConstants.S_OK; } public int GetDefaultSize(Microsoft.VisualStudio.OLE.Interop.SIZE[] size) { if (size.Length >= 1) { size[0].cx = Size.Width; size[0].cy = Size.Height; } return VSConstants.S_OK; } public int LoadViewState(Microsoft.VisualStudio.OLE.Interop.IStream pStream) { return VSConstants.S_OK; } public int SaveViewState(Microsoft.VisualStudio.OLE.Interop.IStream pStream) { return VSConstants.S_OK; } public void RefreshToolbars() { if (_serviceProvider == null) return; IVsUIShell shell = _serviceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; if (shell != null) { shell.UpdateCommandUI(1); } } //[DllImport("ole32.dll")] //static extern int CreateStreamOnHGlobal(IntPtr hGlobal, bool fDeleteOnRelease, // out IStream ppstm); public int SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp) { _serviceProvider = new MyServiceProvider(psp); System.Reflection.MethodInfo mi = _typeQB.GetMethod("Init", System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new Type[] { typeof(System.IServiceProvider), typeof(string) }, null); mi.Invoke(_queryDesigner, new object[] { _serviceProvider, _view.SqlText }); _qbole = _typeQB.InvokeMember("OleCommandTarget", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetProperty, null, _queryDesigner, null) as IOleCommandTarget; _qbbase = _typeQB.InvokeMember("OleInPlaceActiveObject", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetProperty, null, _queryDesigner, null) as IOleInPlaceActiveObject; return VSConstants.S_OK; } private bool EnumWindows(IntPtr hwnd, IntPtr lparam) { if (_qbsql != IntPtr.Zero) return false; StringBuilder builder = new StringBuilder(256); GetClassName(hwnd, builder, builder.Capacity); if (String.Compare(builder.ToString(), "RichEdit20W", StringComparison.OrdinalIgnoreCase) == 0) { _qbsql = hwnd; return false; } EnumChildWindows(hwnd, new EnumWindowsCallback(EnumWindows), IntPtr.Zero); return true; } public int TranslateAccelerator(Microsoft.VisualStudio.OLE.Interop.MSG[] lpmsg) { return VSConstants.S_FALSE; } #endregion public void MakeDirty() { if (_init == true) return; _dirty = true; NotifyChanges(); } #region IOleCommandTarget Members public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { //if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) //{ // switch ((VSConstants.VSStd97CmdID)nCmdID) // { // case VSConstants.VSStd97CmdID.PrimaryKey: // bool newVal = IsPkSelected(); // foreach (Column c in _propertyGrid.SelectedObjects) // { // c.PrimaryKey.Enabled = !newVal; // } // _dataGrid_SelectionChanged(this, EventArgs.Empty); // MakeDirty(); // return VSConstants.S_OK; // } //} //else //if (pguidCmdGroup == SQLiteCommandHandler.guidDavinci) //{ // switch ((VSConstants.VSStd97CmdID)nCmdID) // { // case VSConstants.VSStd97CmdID.ManageIndexes: // IndexHolder holder = new IndexHolder(_table.Indexes, _table.ForeignKeys); // _pg.SelectedObject = holder; // _pg.SelectedGridItem = _pg.SelectedGridItem.Parent.GridItems[0]; // IndexEditor ed = new IndexEditor(_table); // ed.EditValue((ITypeDescriptorContext)_pg.SelectedGridItem, (System.IServiceProvider)_pg.SelectedGridItem, _pg.SelectedGridItem.Value); // return VSConstants.S_OK; // case VSConstants.VSStd97CmdID.ManageRelationships: // holder = new IndexHolder(_table.Indexes, _table.ForeignKeys); // _pg.SelectedObject = holder; // _pg.SelectedGridItem = _pg.SelectedGridItem.Parent.GridItems[1]; // ForeignKeyEditor fed = new ForeignKeyEditor(_table); // fed.EditValue((ITypeDescriptorContext)_pg.SelectedGridItem, (System.IServiceProvider)_pg.SelectedGridItem, _pg.SelectedGridItem.Value); // return VSConstants.S_OK; // case VSConstants.VSStd97CmdID.AlignRight: // Insert Column // _dataGrid.Rows.Insert(_dataGrid.SelectedRows[0].Index, 1); // return VSConstants.S_OK; // case VSConstants.VSStd97CmdID.AlignToGrid: // Delete Column // while (_dataGrid.SelectedRows.Count > 0) // { // try // { // DataGridViewRow row = _dataGrid.SelectedRows[0]; // Column c = row.Tag as Column; // row.Selected = false; // if (c != null) // _table.Columns.Remove(c); // _dataGrid.Rows.Remove(row); // } // catch // { // } // } // return VSConstants.S_OK; // } //} if (_qbole != null) return _qbole.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut); return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); } public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText) { //if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97) //{ // switch ((VSConstants.VSStd97CmdID)prgCmds[0].cmdID) // { // case VSConstants.VSStd97CmdID.PrimaryKey: // prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); // if (IsPkSelected() == true) // prgCmds[0].cmdf |= (uint)(OLECMDF.OLECMDF_LATCHED); // break; // //case VSConstants.VSStd97CmdID.GenerateChangeScript: // // prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); // // break; // default: // return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); // } // return VSConstants.S_OK; //} //if (pguidCmdGroup == SQLiteCommandHandler.guidDavinci) //{ // switch (prgCmds[0].cmdID) // { // //case (uint)VSConstants.VSStd97CmdID.ManageRelationships: // //case (uint)VSConstants.VSStd97CmdID.ManageIndexes: // //case (uint)VSConstants.VSStd97CmdID.ManageConstraints: // //case 10: // Table View -> Custom // //case 14: // Table View -> Modify Custom // //case 33: // Database Diagram -> Add Table // //case 1: // Database Diagram -> Add Related Tables // //case 12: // Database Diagram -> Delete From Database // //case 51: // Database Diagram -> Remove From Diagram // //case 13: // Database Diagram -> Autosize Selected Tables // //case 3: // Database Diagram -> Arrange Selection // //case 2: // Database Diagram -> Arrange Tables // //case 16: // Database Diagram -> Zoom -> 200% // //case 17: // Database Diagram -> Zoom -> 150% // //case 18: // Database Diagram -> Zoom -> 100% // //case 19: // Database Diagram -> Zoom -> 75% // //case 20: // Database Diagram -> Zoom -> 50% // //case 21: // Database Diagram -> Zoom -> 25% // //case 22: // Database Diagram -> Zoom -> 10% // //case 24: // Database Diagram -> Zoom -> To Fit // //case 6: // Database Diagram -> New Text Annotation // //case 15: // Database Diagram -> Set Text Annotation Font // //case 7: // Database Diagram -> Show Relationship Labels // //case 8: // Database Diagram -> View Page Breaks // //case 9: // Database Diagram -> Recalculate Page Breaks // //case 43: // Database Diagram -> Copy Diagram to Clipboard // //case 41: // Query Designer -> Table Display -> Column Names // //case 42: // Query Designer -> Table Display -> Name Only // //case 39: // Query Designer -> Add Table // //case 4: // Insert Column // //case 5: // Delete Column // // prgCmds[0].cmdf = (uint)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED); // // break; // default: // return (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); // } // return VSConstants.S_OK; //} int retval = (int)(Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED); if (_qbole != null) retval = _qbole.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText); //if (pguidCmdGroup == SQLiteCommandHandler.guidQueryGroup) //{ // 0x83 -- show SQL pane // 0x84 -- show diagram pane // 0x0f -- // 0x10 -- // 0x1a -- // 0xc9 -- execute SQL // 0x86 -- show criteria pane // 0x85 -- show results pane // 0x76 -- // 0x6b -- verify sql syntax // 0x79 -- add group by //} return retval; } #endregion #region ISelectionContainer Members int ISelectionContainer.CountObjects(uint dwFlags, out uint pc) { pc = 1; return VSConstants.S_OK; } int ISelectionContainer.GetObjects(uint dwFlags, uint cObjects, object[] apUnkObjects) { apUnkObjects[0] = _view; return VSConstants.S_OK; } int ISelectionContainer.SelectObjects(uint cSelect, object[] apUnkSelect, uint dwFlags) { return VSConstants.S_OK; } #endregion #region IVsWindowPaneCommit Members int IVsWindowPaneCommit.CommitPendingEdit(out int pfCommitFailed) { pfCommitFailed = 0; return VSConstants.S_OK; } #endregion #region IVsWindowFrameNotify Members int IVsWindowFrameNotify.OnDockableChange(int fDockable) { return VSConstants.S_OK; } int IVsWindowFrameNotify.OnMove() { return VSConstants.S_OK; } private void _timer_Tick(object sender, EventArgs e) { _timer.Enabled = false; if (_serviceProvider != null) { EnvDTE.DTE dte = (EnvDTE.DTE)_serviceProvider.GetService(typeof(EnvDTE.DTE)); //Show toolbar if (dte != null) { Microsoft.VisualStudio.CommandBars.CommandBars commandBars = (Microsoft.VisualStudio.CommandBars.CommandBars)dte.CommandBars; Microsoft.VisualStudio.CommandBars.CommandBar bar = commandBars["View Designer"]; bar.Visible = true; } if (_qdinit == false) { _qdinit = true; _init = true; try { _typeQB.InvokeMember("PostInit", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod, null, _queryDesigner, null); if (_qbbase != null) { EnumChildWindows(Handle, new EnumWindowsCallback(EnumWindows), IntPtr.Zero); } _check_Tick(this, EventArgs.Empty); _typeQB.InvokeMember("ShowAddTableDialogIfNeeded", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod, null, _queryDesigner, null); } finally { _init = false; _check.Enabled = true; } } } } int IVsWindowFrameNotify.OnShow(int fShow) { switch ((__FRAMESHOW)fShow) { case __FRAMESHOW.FRAMESHOW_WinShown: SetPropertyWindow(); _timer.Enabled = true; break; case __FRAMESHOW.FRAMESHOW_WinHidden: break; } return VSConstants.S_OK; } int IVsWindowFrameNotify.OnSize() { return VSConstants.S_OK; } #endregion private void _check_Tick(object sender, EventArgs e) { string str = GetRichText(); _view.SqlText = str; } } internal class MyServiceProvider : ServiceProvider { Microsoft.VisualStudio.OLE.Interop.IServiceProvider _psp; internal MyServiceProvider(Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp) { _psp = psp; } protected override object GetServiceImpl(Guid serviceGuid) { IntPtr zero = IntPtr.Zero; Guid unk = new Guid("00000000-0000-0000-c000-000000000046"); Guid self = new Guid("6d5140c1-7436-11ce-8034-00aa006009fa"); if (serviceGuid == self) return this; int status = _psp.QueryService(ref serviceGuid, ref unk, out zero); if (status < 0) { if ((status == -2147467259) || (status == -2147467262)) { return null; } Marshal.ThrowExceptionForHR(status); } object objectForIUnknown = Marshal.GetObjectForIUnknown(zero); Marshal.Release(zero); return objectForIUnknown; } protected override object GetServiceImpl(Type serviceType) { return this.GetService(serviceType.GUID); } } } |
Added SQLite.Designer/Editors/ViewDesignerDoc.resx.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
<?xml version="1.0" encoding="utf-8"?> <root> <!-- Microsoft ResX Schema Version 2.0 The primary goals of this format is to allow a simple XML format that is mostly human readable. The generation and parsing of the various data types are done through the TypeConverter classes associated with the data types. Example: ... ado.net/XML headers & schema ... <resheader name="resmimetype">text/microsoft-resx</resheader> <resheader name="version">2.0</resheader> <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> <value>[base64 mime encoded serialized .NET Framework object]</value> </data> <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> <comment>This is a comment</comment> </data> There are any number of "resheader" rows that contain simple name/value pairs. Each data row contains a name, and value. The row also contains a type or mimetype. Type corresponds to a .NET class that support text/value conversion through the TypeConverter architecture. Classes that don't support this are serialized and stored with the mimetype set. The mimetype is used for serialized objects, and tells the ResXResourceReader how to depersist the object. This is currently not extensible. For a given mimetype the value must be set accordingly: Note - application/x-microsoft.net.object.binary.base64 is the format that the ResXResourceWriter will generate, however the reader can read any of the formats listed below. mimetype: application/x-microsoft.net.object.binary.base64 value : The object must be serialized with : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter : and then encoded with base64 encoding. mimetype: application/x-microsoft.net.object.soap.base64 value : The object must be serialized with : System.Runtime.Serialization.Formatters.Soap.SoapFormatter : and then encoded with base64 encoding. mimetype: application/x-microsoft.net.object.bytearray.base64 value : The object must be serialized into a byte array : using a System.ComponentModel.TypeConverter : and then encoded with base64 encoding. --> <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> <xsd:element name="root" msdata:IsDataSet="true"> <xsd:complexType> <xsd:choice maxOccurs="unbounded"> <xsd:element name="metadata"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" /> </xsd:sequence> <xsd:attribute name="name" use="required" type="xsd:string" /> <xsd:attribute name="type" type="xsd:string" /> <xsd:attribute name="mimetype" type="xsd:string" /> <xsd:attribute ref="xml:space" /> </xsd:complexType> </xsd:element> <xsd:element name="assembly"> <xsd:complexType> <xsd:attribute name="alias" type="xsd:string" /> <xsd:attribute name="name" type="xsd:string" /> </xsd:complexType> </xsd:element> <xsd:element name="data"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> </xsd:sequence> <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> <xsd:attribute ref="xml:space" /> </xsd:complexType> </xsd:element> <xsd:element name="resheader"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> </xsd:sequence> <xsd:attribute name="name" type="xsd:string" use="required" /> </xsd:complexType> </xsd:element> </xsd:choice> </xsd:complexType> </xsd:element> </xsd:schema> <resheader name="resmimetype"> <value>text/microsoft-resx</value> </resheader> <resheader name="version"> <value>2.0</value> </resheader> <resheader name="reader"> <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <resheader name="writer"> <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <metadata name="_timer.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <value>17, 17</value> </metadata> <metadata name="_check.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <value>102, 17</value> </metadata> </root> |
Changes to SQLite.Designer/SQLite.Designer.csproj.
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 .. 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 ... 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 ... 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 |
<PlatformTarget>x86</PlatformTarget> <AllowUnsafeBlocks>false</AllowUnsafeBlocks> <RegisterOutputPackage>false</RegisterOutputPackage> <RegisterWithCodebase>false</RegisterWithCodebase> <GeneratePkgDefFile>false</GeneratePkgDefFile> </PropertyGroup> <ItemGroup> <Reference Include="Microsoft.Data.ConnectionUI, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Common\Assemblies\2005\Microsoft.Data.ConnectionUI.dll</HintPath> <Private>False</Private> </Reference> <Reference Include="Microsoft.VisualStudio.Data, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Common\Assemblies\2005\Microsoft.VisualStudio.Data.dll</HintPath> <Private>False</Private> </Reference> <Reference Include="Microsoft.VisualStudio.OLE.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <SpecificVersion>False</SpecificVersion> ................................................................................ <Compile Include="ChangePasswordDialog.cs"> <SubType>Form</SubType> </Compile> <Compile Include="ChangePasswordDialog.Designer.cs"> <DependentUpon>ChangePasswordDialog.cs</DependentUpon> </Compile> <Compile Include="Design\Column.cs" /> <Compile Include="Design\PrimaryKey.cs" /> <Compile Include="Design\Table.cs" /> <Compile Include="Design\Unique.cs" /> <Compile Include="Editors\AutoCompleteColumn.cs"> <SubType>Component</SubType> </Compile> <Compile Include="Editors\TableDesignerDoc.cs"> <SubType>UserControl</SubType> </Compile> <Compile Include="Editors\TableDesignerDoc.Designer.cs"> <DependentUpon>TableDesignerDoc.cs</DependentUpon> </Compile> <Compile Include="SQLiteAdapterDesigner.cs"> </Compile> <Compile Include="SQLiteCommandDesigner.cs"> </Compile> <Compile Include="SQLiteCommandHandler.cs" /> <Compile Include="SQLiteConnectionProperties.cs" /> <Compile Include="SQLiteConnectionStringEditor.cs" /> ................................................................................ <Compile Include="SQLiteDataObjectIdentifierResolver.cs" /> <Compile Include="SQLiteDataObjectSupport.cs" /> <Compile Include="SQLiteDataSourceInformation.cs" /> <Compile Include="AssemblyInfo.cs" /> <Compile Include="SQLiteDataViewSupport.cs" /> <Compile Include="SQLitePackage.cs" /> <Compile Include="SQLiteProviderObjectFactory.cs" /> <Compile Include="VSPackage.Designer.cs"> <AutoGen>True</AutoGen> <DesignTime>True</DesignTime> <DependentUpon>VSPackage.resx</DependentUpon> </Compile> </ItemGroup> <ItemGroup> <VSCTCompile Include="PkgCmd.vsct"> <ResourceName>1000</ResourceName> </VSCTCompile> </ItemGroup> <ItemGroup> <EmbeddedResource Include="SQLiteDataViewSupport.xml" /> <EmbeddedResource Include="VSPackage.resx"> <Generator>ResXFileCodeGenerator</Generator> <LastGenOutput>VSPackage.Designer.cs</LastGenOutput> <MergeWithCTO>true</MergeWithCTO> <SubType>Designer</SubType> </EmbeddedResource> </ItemGroup> ................................................................................ <EmbeddedResource Include="ChangePasswordDialog.resx"> <SubType>Designer</SubType> <DependentUpon>ChangePasswordDialog.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="Editors\TableDesignerDoc.resx"> <SubType>Designer</SubType> <DependentUpon>TableDesignerDoc.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="SQLiteConnectionUIControl.resx"> <SubType>Designer</SubType> <DependentUpon>SQLiteConnectionUIControl.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="SQLiteDataObjectSupport.xml" /> </ItemGroup> <ItemGroup> <Folder Include="Properties\" /> <Folder Include="Resources\" /> </ItemGroup> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v9.0\VSSDK\Microsoft.VsSDK.targets" /> <PropertyGroup> <PostBuildEvent> </PostBuildEvent> </PropertyGroup> </Project> |
> > > > > > > > > > > > > > > > > > > > > > > | > > > > > > > > > |
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 .. 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 ... 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 ... 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
<PlatformTarget>x86</PlatformTarget> <AllowUnsafeBlocks>false</AllowUnsafeBlocks> <RegisterOutputPackage>false</RegisterOutputPackage> <RegisterWithCodebase>false</RegisterWithCodebase> <GeneratePkgDefFile>false</GeneratePkgDefFile> </PropertyGroup> <ItemGroup> <Reference Include="EnvDTE, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies\EnvDTE.dll</HintPath> </Reference> <Reference Include="Microsoft.Data.ConnectionUI, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Common\Assemblies\2005\Microsoft.Data.ConnectionUI.dll</HintPath> <Private>False</Private> </Reference> <Reference Include="Microsoft.VisualStudio.CommandBars, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Common Files\Microsoft Shared\MSEnv\PublicAssemblies\Microsoft.VisualStudio.CommandBars.dll</HintPath> </Reference> <Reference Include="Microsoft.VisualStudio.Data, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"> <SpecificVersion>False</SpecificVersion> <HintPath>..\..\..\Program Files (x86)\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Common\Assemblies\2005\Microsoft.VisualStudio.Data.dll</HintPath> <Private>False</Private> </Reference> <Reference Include="Microsoft.VisualStudio.OLE.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"> <SpecificVersion>False</SpecificVersion> ................................................................................ <Compile Include="ChangePasswordDialog.cs"> <SubType>Form</SubType> </Compile> <Compile Include="ChangePasswordDialog.Designer.cs"> <DependentUpon>ChangePasswordDialog.cs</DependentUpon> </Compile> <Compile Include="Design\Column.cs" /> <Compile Include="Design\ForeignKey.cs" /> <Compile Include="Design\Index.cs" /> <Compile Include="Design\PrimaryKey.cs" /> <Compile Include="Design\Table.cs" /> <Compile Include="Design\Unique.cs" /> <Compile Include="Design\View.cs" /> <Compile Include="Editors\AutoCompleteColumn.cs"> <SubType>Component</SubType> </Compile> <Compile Include="Editors\TableDesignerDoc.cs"> <SubType>UserControl</SubType> </Compile> <Compile Include="Editors\TableDesignerDoc.Designer.cs"> <DependentUpon>TableDesignerDoc.cs</DependentUpon> </Compile> <Compile Include="Editors\ViewDesignerDoc.cs"> <SubType>UserControl</SubType> </Compile> <Compile Include="Editors\ViewDesignerDoc.Designer.cs"> <DependentUpon>ViewDesignerDoc.cs</DependentUpon> </Compile> <Compile Include="SQLiteAdapterDesigner.cs"> </Compile> <Compile Include="SQLiteCommandDesigner.cs"> </Compile> <Compile Include="SQLiteCommandHandler.cs" /> <Compile Include="SQLiteConnectionProperties.cs" /> <Compile Include="SQLiteConnectionStringEditor.cs" /> ................................................................................ <Compile Include="SQLiteDataObjectIdentifierResolver.cs" /> <Compile Include="SQLiteDataObjectSupport.cs" /> <Compile Include="SQLiteDataSourceInformation.cs" /> <Compile Include="AssemblyInfo.cs" /> <Compile Include="SQLiteDataViewSupport.cs" /> <Compile Include="SQLitePackage.cs" /> <Compile Include="SQLiteProviderObjectFactory.cs" /> <Compile Include="TableNameDialog.cs"> <SubType>Form</SubType> </Compile> <Compile Include="TableNameDialog.Designer.cs"> <DependentUpon>TableNameDialog.cs</DependentUpon> </Compile> <Compile Include="VSPackage.Designer.cs"> <AutoGen>True</AutoGen> <DesignTime>True</DesignTime> <DependentUpon>VSPackage.resx</DependentUpon> </Compile> </ItemGroup> <ItemGroup> <VSCTCompile Include="PkgCmd.vsct"> <ResourceName>1000</ResourceName> </VSCTCompile> </ItemGroup> <ItemGroup> <EmbeddedResource Include="SQLiteDataViewSupport2008.xml" /> <EmbeddedResource Include="VSPackage.resx"> <Generator>ResXFileCodeGenerator</Generator> <LastGenOutput>VSPackage.Designer.cs</LastGenOutput> <MergeWithCTO>true</MergeWithCTO> <SubType>Designer</SubType> </EmbeddedResource> </ItemGroup> ................................................................................ <EmbeddedResource Include="ChangePasswordDialog.resx"> <SubType>Designer</SubType> <DependentUpon>ChangePasswordDialog.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="Editors\TableDesignerDoc.resx"> <SubType>Designer</SubType> <DependentUpon>TableDesignerDoc.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="Editors\ViewDesignerDoc.resx"> <DependentUpon>ViewDesignerDoc.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="SQLiteConnectionUIControl.resx"> <SubType>Designer</SubType> <DependentUpon>SQLiteConnectionUIControl.cs</DependentUpon> </EmbeddedResource> <EmbeddedResource Include="SQLiteDataObjectSupport.xml" /> <EmbeddedResource Include="TableNameDialog.resx"> <DependentUpon>TableNameDialog.cs</DependentUpon> </EmbeddedResource> </ItemGroup> <ItemGroup> <EmbeddedResource Include="SQLiteDataViewSupport2005.xml" /> </ItemGroup> <ItemGroup> <Folder Include="Properties\" /> <Folder Include="Resources\" /> </ItemGroup> <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v9.0\VSSDK\Microsoft.VsSDK.targets" /> <PropertyGroup> <PostBuildEvent> </PostBuildEvent> </PropertyGroup> </Project> |
Changes to SQLite.Designer/SQLiteCommandHandler.cs.
29 30 31 32 33 34 35 36 37 38 39 40 41 42 .. 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 ... 129 130 131 132 133 134 135 136 137 138 139 140 141 142 ... 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 |
internal sealed class SQLiteCommandHandler : DataViewCommandHandler { internal static readonly Guid guidDataCmdSet = new Guid("501822E1-B5AF-11d0-B4DC-00A0C91506EF"); internal static readonly Guid guidSQLiteCmdSet = new Guid("814658EE-A28E-4b97-BC33-4B1BC81EBECB"); internal static readonly Guid guidIFCmdId = new Guid("{74d21311-2aee-11d1-8bfb-00a0c90f26f7}"); internal static readonly Guid guidDavinci = new Guid("{732abe75-cd80-11d0-a2db-00aa00a3efff}"); internal static readonly Guid guidDavinciGrp = new Guid("{732abe74-cd80-11d0-a2db-00aa00a3efff}"); public SQLiteCommandHandler() { } public override OleCommandStatus GetCommandStatus(int[] itemIds, OleCommand command, OleCommandTextType textType, OleCommandStatus status) { ................................................................................ switch ((cmdid)command.CommandId) { case cmdid.Alter: status.Supported = true; status.Visible = true; status.Enabled = (SystemTableSelected == false && SystemIndexSelected == false); return status; //case cmdid.CreateTable: //case cmdid.CreateView: // status.Supported = true; // status.Visible = true; // status.Enabled = true; // return status; } } base.GetCommandStatus(itemIds, command, textType, status); return status; } ................................................................................ return true; } } return false; } } /// <summary> /// This method executes a specified command, potentially based /// on parameters passed in from the data view support XML. /// </summary> public override object ExecuteCommand(int itemId, OleCommand command, OleCommandExecutionOption executionOption, object arguments) { object returnValue = null; ................................................................................ } } else if (command.GroupGuid == guidDataCmdSet) { switch ((cmdid)command.CommandId) { case cmdid.CreateTable: CreateTable(itemId); break; case cmdid.CreateView: CreateView(itemId); break; case cmdid.Alter: switch ((string)args[0]) { case "Table": break; case "Index": break; case "View": break; } break; } } else { returnValue = base.ExecuteCommand(itemId, command, executionOption, arguments); } return returnValue; } private void CreateTable(int itemId) { Microsoft.VisualStudio.OLE.Interop.IServiceProvider provider = DataViewHierarchyAccessor.ServiceProvider as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; IVsUIShell shell = DataViewHierarchyAccessor.ServiceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; IVsUIHierarchy hier = DataViewHierarchyAccessor.Hierarchy; IVsWindowFrame frame; if (shell != null) { TableDesignerDoc form = new TableDesignerDoc(DataViewHierarchyAccessor.Connection, null); IntPtr formptr = System.Runtime.InteropServices.Marshal.GetIUnknownForObject(form); Guid empty = Guid.Empty; FakeHierarchy fake = new FakeHierarchy(form, hier); int code = shell.CreateDocumentWindow( 0, // (uint)(__VSCREATEDOCWIN.CDW_fCreateNewWindow | __VSCREATEDOCWIN.CDW_RDTFLAGS_MASK) | (uint)(_VSRDTFLAGS.RDT_CanBuildFromMemory | _VSRDTFLAGS.RDT_NonCreatable | _VSRDTFLAGS.RDT_VirtualDocument | _VSRDTFLAGS.RDT_DontAddToMRU), form.Name, fake, (uint)itemId, formptr, formptr, ref empty, null, ref empty, provider, "SQLite:", form.Name, null, out frame); if (frame != null) { object ret; int prop = (int)__VSFPROPID.VSFPROPID_Caption; code = frame.GetProperty(prop, out ret); code = frame.Show(); } } // TODO: Implement this command } private void CreateView(int itemId) { // TODO: Implement this command } private void DropSelectedTables() { int[] items = DataViewHierarchyAccessor.GetSelectedItems(); int n; object[] parts; |
> | | | | | | > > > > | | > > > > > > > > > > > > | | | < < > > | > > > > > > > > > > > > > > > > > > > > > > > > |
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 .. 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 ... 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 ... 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 |
internal sealed class SQLiteCommandHandler : DataViewCommandHandler { internal static readonly Guid guidDataCmdSet = new Guid("501822E1-B5AF-11d0-B4DC-00A0C91506EF"); internal static readonly Guid guidSQLiteCmdSet = new Guid("814658EE-A28E-4b97-BC33-4B1BC81EBECB"); internal static readonly Guid guidIFCmdId = new Guid("{74d21311-2aee-11d1-8bfb-00a0c90f26f7}"); internal static readonly Guid guidDavinci = new Guid("{732abe75-cd80-11d0-a2db-00aa00a3efff}"); internal static readonly Guid guidDavinciGrp = new Guid("{732abe74-cd80-11d0-a2db-00aa00a3efff}"); internal static readonly Guid guidQueryGroup = new Guid("5efc7975-14bc-11cf-9b2b-00aa00573819"); public SQLiteCommandHandler() { } public override OleCommandStatus GetCommandStatus(int[] itemIds, OleCommand command, OleCommandTextType textType, OleCommandStatus status) { ................................................................................ switch ((cmdid)command.CommandId) { case cmdid.Alter: status.Supported = true; status.Visible = true; status.Enabled = (SystemTableSelected == false && SystemIndexSelected == false); return status; case cmdid.CreateTable: case cmdid.CreateView: status.Supported = true; status.Visible = true; status.Enabled = true; return status; } } base.GetCommandStatus(itemIds, command, textType, status); return status; } ................................................................................ return true; } } return false; } } public override object[] ExecuteCommand(int[] itemIds, OleCommand command, OleCommandExecutionOption executionOption, object arguments) { return base.ExecuteCommand(itemIds, command, executionOption, arguments); } /// <summary> /// This method executes a specified command, potentially based /// on parameters passed in from the data view support XML. /// </summary> public override object ExecuteCommand(int itemId, OleCommand command, OleCommandExecutionOption executionOption, object arguments) { object returnValue = null; ................................................................................ } } else if (command.GroupGuid == guidDataCmdSet) { switch ((cmdid)command.CommandId) { case cmdid.CreateTable: DesignTable(itemId, null); break; case cmdid.CreateView: DesignView(itemId, null); break; case cmdid.Alter: switch ((string)args[0]) { case "Table": { object[] parts; int[] items = DataViewHierarchyAccessor.GetSelectedItems(); parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[0]); DesignTable(itemId, parts[2].ToString()); } break; case "Index": break; case "View": { object[] parts; int[] items = DataViewHierarchyAccessor.GetSelectedItems(); parts = DataViewHierarchyAccessor.GetObjectIdentifier(items[0]); DesignView(itemId, parts[2].ToString()); } break; } break; } } else { returnValue = base.ExecuteCommand(itemId, command, executionOption, arguments); } return returnValue; } private void DesignTable(int itemId, string tableName) { Microsoft.VisualStudio.OLE.Interop.IServiceProvider provider = DataViewHierarchyAccessor.ServiceProvider as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; IVsUIShell shell = DataViewHierarchyAccessor.ServiceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; IVsUIHierarchy hier = DataViewHierarchyAccessor.Hierarchy; IVsWindowFrame frame; if (shell != null) { TableDesignerDoc form = new TableDesignerDoc(DataViewHierarchyAccessor.Connection, tableName); IntPtr formptr = System.Runtime.InteropServices.Marshal.GetIUnknownForObject(form); Guid empty = Guid.Empty; FakeHierarchy fake = new FakeHierarchy(form, hier); int code = shell.CreateDocumentWindow( 0, // (uint)(__VSCREATEDOCWIN.CDW_fCreateNewWindow | __VSCREATEDOCWIN.CDW_RDTFLAGS_MASK) | (uint)(_VSRDTFLAGS.RDT_CanBuildFromMemory | _VSRDTFLAGS.RDT_NonCreatable | _VSRDTFLAGS.RDT_VirtualDocument | _VSRDTFLAGS.RDT_DontAddToMRU), form.Name, fake, (uint)itemId, formptr, formptr, ref empty, null, ref empty, provider, "", form.Caption, null, out frame); if (frame != null) { object ret; int prop = (int)__VSFPROPID.VSFPROPID_Caption; code = frame.GetProperty(prop, out ret); code = frame.Show(); } } } private void DesignView(int itemId, string viewName) { Microsoft.VisualStudio.OLE.Interop.IServiceProvider provider = DataViewHierarchyAccessor.ServiceProvider as Microsoft.VisualStudio.OLE.Interop.IServiceProvider; IVsUIShell shell = DataViewHierarchyAccessor.ServiceProvider.GetService(typeof(IVsUIShell)) as IVsUIShell; IVsUIHierarchy hier = DataViewHierarchyAccessor.Hierarchy; IVsWindowFrame frame; if (shell != null) { ViewDesignerDoc form = new ViewDesignerDoc(DataViewHierarchyAccessor.Connection, viewName); IntPtr formptr = System.Runtime.InteropServices.Marshal.GetIUnknownForObject(form); Guid empty = Guid.Empty; FakeHierarchy fake = new FakeHierarchy(form, hier); int code = shell.CreateDocumentWindow( 0, // (uint)(__VSCREATEDOCWIN.CDW_fCreateNewWindow | __VSCREATEDOCWIN.CDW_RDTFLAGS_MASK) | (uint)(_VSRDTFLAGS.RDT_CanBuildFromMemory | _VSRDTFLAGS.RDT_NonCreatable | _VSRDTFLAGS.RDT_VirtualDocument | _VSRDTFLAGS.RDT_DontAddToMRU), form.Name, fake, (uint)itemId, formptr, formptr, ref empty, null, ref empty, provider, "", form.Caption, null, out frame); if (frame != null) { object ret; int prop = (int)__VSFPROPID.VSFPROPID_Caption; code = frame.GetProperty(prop, out ret); code = frame.Show(); } } } private void DropSelectedTables() { int[] items = DataViewHierarchyAccessor.GetSelectedItems(); int n; object[] parts; |
Added SQLite.Designer/SQLiteConnectionUIControl.resources.
cannot compute difference between binary files
Changes to SQLite.Designer/SQLiteDataViewSupport.cs.
16 17 18 19 20 21 22 23 24 25 26 27 |
/// <summary>
/// Provides DataViewSupport with a location where the XML file is for the Server Explorer's view.
/// </summary>
internal sealed class SQLiteDataViewSupport : DataViewSupport
{
public SQLiteDataViewSupport()
: base("SQLite.Designer.SQLiteDataViewSupport", typeof(SQLiteDataViewSupport).Assembly)
{
}
}
}
|
| > > > > > > > > > > > |
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
/// <summary> /// Provides DataViewSupport with a location where the XML file is for the Server Explorer's view. /// </summary> internal sealed class SQLiteDataViewSupport : DataViewSupport { public SQLiteDataViewSupport() : base(String.Format("SQLite.Designer.SQLiteDataViewSupport{0}", GetVSVersion()), typeof(SQLiteDataViewSupport).Assembly) { } private static string GetVSVersion() { switch (System.Diagnostics.FileVersionInfo.GetVersionInfo(Environment.GetCommandLineArgs()[0]).FileMajorPart) { case 8: return "2005"; default: return "2008"; } } } } |
Deleted SQLite.Designer/SQLiteDataViewSupport.xml.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 |
<?xml version="1.0" encoding="utf-8"?> <!-- /******************************************************** * ADO.NET 2.0 Data Provider for SQLite Version 3.X * Written by Robert Simpson (robert@blackcastlesoft.com) * * Released to the public domain, use at your own risk! ********************************************************/ --> <VSDataViewSupport xmlns="http://tempuri.org/VSDataViewSupport.xsd"> <DataViews> <!-- This sample defines a single data view --> <DataView name="SQLite"> <DisplayName>SQLite</DisplayName> <!-- The connection node is static, i.e. has no underlying object --> <StaticConnectionNode> <!-- We can always specify data from the root object --> <InitialDisplayName>SQLite [{Root.Server}]</InitialDisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="Vacuum" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="262" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="Rekey" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="263" handler="SQLite.Designer.SQLiteCommandHandler"/> </CommandBindings> <Children> <StaticNode nid="Tables"> <DisplayName>Tables</DisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Tables"> <DisplayName>System Tables</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='SYSTEM_TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Views"> <DisplayName>Views</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="NewView" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13601" handler="SQLite.Designer.SQLiteCommandHandler" /> </CommandBindings> <Children> <Selection type="View"> <SelectionNode nid="View"> <DisplayName>{View.Name}</DisplayName> <Icon name="View"/> <Children> <Selection type="ViewColumn" restrictions="{View.Database},null,{View.Name}"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </SelectionNode> </Selection> </Children> </StaticNode> </Children> </StaticConnectionNode> </DataView> </DataViews> <SubHierarchies> <SubHierarchy name="table children"> <StaticNode nid="Columns"> <DisplayName>Columns</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=True"> <SelectionNode> <Icon name="PrimaryKey"/> </SelectionNode> </Selection> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=False"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Indexes"> <DisplayName>Indexes</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Index" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon when="{IsPrimary}=true" name="PrimaryKey"/> <Icon when="{IsUnique}=true" name="UniqueKey"/> <Icon name="Index"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="ForeignKeys"> <DisplayName>Foreign Keys</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="ForeignKey" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon name="ForeignKey"/> </SelectionNode> </Selection> </Children> </StaticNode> </SubHierarchy> </SubHierarchies> <TypeExtensions> <TypeExtension name="Table"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropTable" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> <CommandBinding name="Browse_Data" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="884DD964-5327-461f-9F06-6484DD540F8F"> <Parameter value="Open"/> </CommandBinding> <!--<CommandBinding name="Browse_DataVS2005" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="Microsoft.VisualStudio.DataTools.DBPackage.VDT_OLEDB_CommandHandler_TableTools"> <Parameter value="Open"/> </CommandBinding>--> <CommandBinding name="Design" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12291" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="View"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUpdatable"> <DisplayName>Updatable</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropView" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="View"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="ViewColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <Category resource="Category_Location"/> </Part> <Part name="View"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="Index"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUnique"> <DisplayName>Is Unique</DisplayName> </Property> <Property name="IsPrimary"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropIndex" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Index"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="TableColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="Length"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> <Property name="InPrimaryKey"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="ForeignKey"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="ColumnName"> <DisplayName>Source Column</DisplayName> <Category resource="Category_Source"/> </Property> <Property name="ReferencedTableDatabase"> <DisplayName>Referenced Database</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedTableName"> <DisplayName>Referenced Table</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedColumnName"> <DisplayName>Referenced Column</DisplayName> <Category resource="Category_Refs"/> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> </TypeExtensions> <Resources baseName="SQLite.Designer.VSPackage"> <Resource name="Category_Identity">(Identity)</Resource> <Resource name="Category_Location">(Location)</Resource> <Resource name="Category_Source">(Source)</Resource> <Resource name="Category_Refs">References</Resource> </Resources> </VSDataViewSupport> |
< < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < |
Added SQLite.Designer/SQLiteDataViewSupport2005.xml.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 |
<?xml version="1.0" encoding="utf-8"?> <!-- /******************************************************** * ADO.NET 2.0 Data Provider for SQLite Version 3.X * Written by Robert Simpson (robert@blackcastlesoft.com) * * Released to the public domain, use at your own risk! ********************************************************/ --> <VSDataViewSupport xmlns="http://tempuri.org/VSDataViewSupport.xsd"> <DataViews> <!-- This sample defines a single data view --> <DataView name="SQLite"> <DisplayName>SQLite</DisplayName> <!-- The connection node is static, i.e. has no underlying object --> <StaticConnectionNode> <!-- We can always specify data from the root object --> <InitialDisplayName>SQLite [{Root.Server}]</InitialDisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="Vacuum" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="262" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="Rekey" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="263" handler="SQLite.Designer.SQLiteCommandHandler"/> </CommandBindings> <Children> <StaticNode nid="Tables"> <DisplayName>Tables</DisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Tables"> <DisplayName>System Tables</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='SYSTEM_TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Views"> <DisplayName>Views</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="NewView" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13601" handler="SQLite.Designer.SQLiteCommandHandler" /> </CommandBindings> <Children> <Selection type="View"> <SelectionNode nid="View"> <DisplayName>{View.Name}</DisplayName> <Icon name="View"/> <Children> <Selection type="ViewColumn" restrictions="{View.Database},null,{View.Name}"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </SelectionNode> </Selection> </Children> </StaticNode> </Children> </StaticConnectionNode> </DataView> </DataViews> <SubHierarchies> <SubHierarchy name="table children"> <StaticNode nid="Columns"> <DisplayName>Columns</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=True"> <SelectionNode> <Icon name="PrimaryKey"/> </SelectionNode> </Selection> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=False"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Indexes"> <DisplayName>Indexes</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Index" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon when="{IsPrimary}=true" name="PrimaryKey"/> <Icon when="{IsUnique}=true" name="UniqueKey"/> <Icon name="Index"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="ForeignKeys"> <DisplayName>Foreign Keys</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="ForeignKey" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon name="ForeignKey"/> </SelectionNode> </Selection> </Children> </StaticNode> </SubHierarchy> </SubHierarchies> <TypeExtensions> <TypeExtension name="Table"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropTable" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> <CommandBinding name="Browse_DataVS2005" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="Microsoft.VisualStudio.DataTools.DBPackage.VDT_OLEDB_CommandHandler_TableTools"> <Parameter value="Open"/> </CommandBinding> <CommandBinding name="Design" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12291" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="View"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUpdatable"> <DisplayName>Updatable</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropView" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="View"/> </CommandBinding> <CommandBinding name="Design" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12291" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="View"/> </CommandBinding> <CommandBinding name="Browse_DataVS2005" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="Microsoft.VisualStudio.DataTools.DBPackage.VDT_OLEDB_CommandHandler_TableTools"> <Parameter value="Open"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="ViewColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <Category resource="Category_Location"/> </Part> <Part name="View"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="Index"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUnique"> <DisplayName>Is Unique</DisplayName> </Property> <Property name="IsPrimary"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropIndex" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Index"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="TableColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="Length"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> <Property name="InPrimaryKey"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="ForeignKey"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="ColumnName"> <DisplayName>Source Column</DisplayName> <Category resource="Category_Source"/> </Property> <Property name="ReferencedTableDatabase"> <DisplayName>Referenced Database</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedTableName"> <DisplayName>Referenced Table</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedColumnName"> <DisplayName>Referenced Column</DisplayName> <Category resource="Category_Refs"/> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> </TypeExtensions> <Resources baseName="SQLite.Designer.VSPackage"> <Resource name="Category_Identity">(Identity)</Resource> <Resource name="Category_Location">(Location)</Resource> <Resource name="Category_Source">(Source)</Resource> <Resource name="Category_Refs">References</Resource> </Resources> </VSDataViewSupport> |
Added SQLite.Designer/SQLiteDataViewSupport2008.xml.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 |
<?xml version="1.0" encoding="utf-8"?> <!-- /******************************************************** * ADO.NET 2.0 Data Provider for SQLite Version 3.X * Written by Robert Simpson (robert@blackcastlesoft.com) * * Released to the public domain, use at your own risk! ********************************************************/ --> <VSDataViewSupport xmlns="http://tempuri.org/VSDataViewSupport.xsd"> <DataViews> <!-- This sample defines a single data view --> <DataView name="SQLite"> <DisplayName>SQLite</DisplayName> <!-- The connection node is static, i.e. has no underlying object --> <StaticConnectionNode> <!-- We can always specify data from the root object --> <InitialDisplayName>SQLite [{Root.Server}]</InitialDisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="Vacuum" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="262" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="Rekey" guid="814658EE-A28E-4b97-BC33-4B1BC81EBECB" cmdid="263" handler="SQLite.Designer.SQLiteCommandHandler"/> </CommandBindings> <Children> <StaticNode nid="Tables"> <DisplayName>Tables</DisplayName> <CommandBindings> <CommandBinding name="NewTable" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13600" handler="SQLite.Designer.SQLiteCommandHandler"/> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Tables"> <DisplayName>System Tables</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Table" filter="TYPE='SYSTEM_TABLE'"> <SelectionNode nid="Table"> <Icon name="Table"/> <Children> <SubHierarchyRef name="Table children"/> </Children> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Views"> <DisplayName>Views</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="NewView" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13601" handler="SQLite.Designer.SQLiteCommandHandler" /> </CommandBindings> <Children> <Selection type="View"> <SelectionNode nid="View"> <DisplayName>{View.Name}</DisplayName> <Icon name="View"/> <Children> <Selection type="ViewColumn" restrictions="{View.Database},null,{View.Name}"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </SelectionNode> </Selection> </Children> </StaticNode> </Children> </StaticConnectionNode> </DataView> </DataViews> <SubHierarchies> <SubHierarchy name="table children"> <StaticNode nid="Columns"> <DisplayName>Columns</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=True"> <SelectionNode> <Icon name="PrimaryKey"/> </SelectionNode> </Selection> <Selection type="TableColumn" restrictions="{Table.Database},null,{Table.Name}" filter="InPrimaryKey=False"> <SelectionNode> <Icon name="Column"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="Indexes"> <DisplayName>Indexes</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="Index" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon when="{IsPrimary}=true" name="PrimaryKey"/> <Icon when="{IsUnique}=true" name="UniqueKey"/> <Icon name="Index"/> </SelectionNode> </Selection> </Children> </StaticNode> <StaticNode nid="ForeignKeys"> <DisplayName>Foreign Keys</DisplayName> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> <Children> <Selection type="ForeignKey" restrictions="{Table.Database},null,{Table.Name}"> <SelectionNode> <Icon name="ForeignKey"/> </SelectionNode> </Selection> </Children> </StaticNode> </SubHierarchy> </SubHierarchies> <TypeExtensions> <TypeExtension name="Table"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropTable" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> <CommandBinding name="Browse_Data" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="884DD964-5327-461f-9F06-6484DD540F8F"> <Parameter value="Open"/> </CommandBinding> <CommandBinding name="Design" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12291" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Table"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="View"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUpdatable"> <DisplayName>Updatable</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropView" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="View"/> </CommandBinding> <CommandBinding name="Design" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12291" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="View"/> </CommandBinding> <CommandBinding name="Browse_Data" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="12384" handler="884DD964-5327-461f-9F06-6484DD540F8F"> <Parameter value="Open"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="ViewColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <Category resource="Category_Location"/> </Part> <Part name="View"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="Index"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="IsUnique"> <DisplayName>Is Unique</DisplayName> </Property> <Property name="IsPrimary"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> <CommandBinding name="DropIndex" guid="5efc7975-14bc-11cf-9b2b-00aa00573819" cmdid="17" handler="SQLite.Designer.SQLiteCommandHandler"> <Parameter value="Index"/> </CommandBinding> </CommandBindings> </TypeExtension> <TypeExtension name="TableColumn"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="Ordinal"/> <Property name="Length"/> <Property name="DataType"> <DisplayName>Data Type</DisplayName> </Property> <Property name="Nullable"> <DisplayName>Allow Nulls</DisplayName> </Property> <Property name="Default"> <DisplayName>Default Value</DisplayName> </Property> <Property name="InPrimaryKey"> <DisplayName>Primary Key</DisplayName> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> <TypeExtension name="ForeignKey"> <Identifier> <Part name="Name"> <Category resource="Category_Identity"/> </Part> <Part name="Database"> <DisplayName>Catalog</DisplayName> <Category resource="Category_Location"/> </Part> <Part name="Table"> <Category resource="Category_Location"/> </Part> </Identifier> <Properties> <Property name="ColumnName"> <DisplayName>Source Column</DisplayName> <Category resource="Category_Source"/> </Property> <Property name="ReferencedTableDatabase"> <DisplayName>Referenced Database</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedTableName"> <DisplayName>Referenced Table</DisplayName> <Category resource="Category_Refs"/> </Property> <Property name="ReferencedColumnName"> <DisplayName>Referenced Column</DisplayName> <Category resource="Category_Refs"/> </Property> </Properties> <CommandBindings> <CommandBinding name="NewQuery" guid="501822E1-B5AF-11d0-B4DC-00A0C91506EF" cmdid="13608" handler="884DD964-5327-461f-9F06-6484DD540F8F"/> </CommandBindings> </TypeExtension> </TypeExtensions> <Resources baseName="SQLite.Designer.VSPackage"> <Resource name="Category_Identity">(Identity)</Resource> <Resource name="Category_Location">(Location)</Resource> <Resource name="Category_Source">(Source)</Resource> <Resource name="Category_Refs">References</Resource> </Resources> </VSDataViewSupport> |
Added SQLite.Designer/TableNameDialog.Designer.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
namespace SQLite.Designer { partial class TableNameDialog { /// <summary> /// Required designer variable. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); } #region Windows Form Designer generated code /// <summary> /// Required method for Designer support - do not modify /// the contents of this method with the code editor. /// </summary> private void InitializeComponent() { System.Windows.Forms.Button _ok; System.Windows.Forms.Button _cancel; this.label1 = new System.Windows.Forms.Label(); this._name = new System.Windows.Forms.TextBox(); _ok = new System.Windows.Forms.Button(); _cancel = new System.Windows.Forms.Button(); this.SuspendLayout(); // // _ok // _ok.Location = new System.Drawing.Point(211, 51); _ok.Name = "_ok"; _ok.Size = new System.Drawing.Size(75, 23); _ok.TabIndex = 2; _ok.Text = "OK"; _ok.UseVisualStyleBackColor = true; _ok.Click += new System.EventHandler(this._ok_Click); // // _cancel // _cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; _cancel.Location = new System.Drawing.Point(292, 51); _cancel.Name = "_cancel"; _cancel.Size = new System.Drawing.Size(75, 23); _cancel.TabIndex = 3; _cancel.Text = "Cancel"; _cancel.UseVisualStyleBackColor = true; _cancel.Click += new System.EventHandler(this._cancel_Click); // // label1 // this.label1.AutoSize = true; this.label1.Location = new System.Drawing.Point(12, 9); this.label1.Name = "label1"; this.label1.Size = new System.Drawing.Size(126, 13); this.label1.TabIndex = 0; this.label1.Text = "Choose a &name for this %"; // // _name // this._name.Location = new System.Drawing.Point(12, 25); this._name.Name = "_name"; this._name.Size = new System.Drawing.Size(355, 20); this._name.TabIndex = 1; // // TableNameDialog // this.AcceptButton = _ok; this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.CancelButton = _cancel; this.ClientSize = new System.Drawing.Size(379, 86); this.Controls.Add(this._name); this.Controls.Add(this.label1); this.Controls.Add(_cancel); this.Controls.Add(_ok); this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; this.MaximizeBox = false; this.MinimizeBox = false; this.Name = "TableNameDialog"; this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent; this.Text = "% Name"; this.ResumeLayout(false); this.PerformLayout(); } #endregion private System.Windows.Forms.Label label1; private System.Windows.Forms.TextBox _name; } } |
Added SQLite.Designer/TableNameDialog.cs.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; namespace SQLite.Designer { public partial class TableNameDialog : Form { public TableNameDialog() : this("Table", null) { } public TableNameDialog(string type, string defaultName) { InitializeComponent(); Text = Text.Replace("%", type); label1.Text = label1.Text.Replace("%", type.ToLower()); _name.Text = defaultName; } public string TableName { get { return _name.Text; } set { _name.Text = value; } } private void _ok_Click(object sender, EventArgs e) { DialogResult = DialogResult.OK; Close(); } private void _cancel_Click(object sender, EventArgs e) { DialogResult = DialogResult.Cancel; Close(); } } } |
Added SQLite.Designer/TableNameDialog.resx.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
<?xml version="1.0" encoding="utf-8"?> <root> <!-- Microsoft ResX Schema Version 2.0 The primary goals of this format is to allow a simple XML format that is mostly human readable. The generation and parsing of the various data types are done through the TypeConverter classes associated with the data types. Example: ... ado.net/XML headers & schema ... <resheader name="resmimetype">text/microsoft-resx</resheader> <resheader name="version">2.0</resheader> <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> <value>[base64 mime encoded serialized .NET Framework object]</value> </data> <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> <comment>This is a comment</comment> </data> There are any number of "resheader" rows that contain simple name/value pairs. Each data row contains a name, and value. The row also contains a type or mimetype. Type corresponds to a .NET class that support text/value conversion through the TypeConverter architecture. Classes that don't support this are serialized and stored with the mimetype set. The mimetype is used for serialized objects, and tells the ResXResourceReader how to depersist the object. This is currently not extensible. For a given mimetype the value must be set accordingly: Note - application/x-microsoft.net.object.binary.base64 is the format that the ResXResourceWriter will generate, however the reader can read any of the formats listed below. mimetype: application/x-microsoft.net.object.binary.base64 value : The object must be serialized with : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter : and then encoded with base64 encoding. mimetype: application/x-microsoft.net.object.soap.base64 value : The object must be serialized with : System.Runtime.Serialization.Formatters.Soap.SoapFormatter : and then encoded with base64 encoding. mimetype: application/x-microsoft.net.object.bytearray.base64 value : The object must be serialized into a byte array : using a System.ComponentModel.TypeConverter : and then encoded with base64 encoding. --> <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> <xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> <xsd:element name="root" msdata:IsDataSet="true"> <xsd:complexType> <xsd:choice maxOccurs="unbounded"> <xsd:element name="metadata"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" /> </xsd:sequence> <xsd:attribute name="name" use="required" type="xsd:string" /> <xsd:attribute name="type" type="xsd:string" /> <xsd:attribute name="mimetype" type="xsd:string" /> <xsd:attribute ref="xml:space" /> </xsd:complexType> </xsd:element> <xsd:element name="assembly"> <xsd:complexType> <xsd:attribute name="alias" type="xsd:string" /> <xsd:attribute name="name" type="xsd:string" /> </xsd:complexType> </xsd:element> <xsd:element name="data"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> </xsd:sequence> <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> <xsd:attribute ref="xml:space" /> </xsd:complexType> </xsd:element> <xsd:element name="resheader"> <xsd:complexType> <xsd:sequence> <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> </xsd:sequence> <xsd:attribute name="name" type="xsd:string" use="required" /> </xsd:complexType> </xsd:element> </xsd:choice> </xsd:complexType> </xsd:element> </xsd:schema> <resheader name="resmimetype"> <value>text/microsoft-resx</value> </resheader> <resheader name="version"> <value>2.0</value> </resheader> <resheader name="reader"> <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <resheader name="writer"> <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> </resheader> <metadata name="_ok.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>False</value> </metadata> <metadata name="_cancel.GenerateMember" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"> <value>False</value> </metadata> </root> |
Changes to SQLite.Interop/SQLite.Interop.rc.
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
..
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
///////////////////////////////////////////////////////////////////////////// // // Version // VS_VERSION_INFO VERSIONINFO FILEVERSION 1,0,50,0 PRODUCTVERSION 1,0,0,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L #else FILEFLAGS 0x0L #endif ................................................................................ BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904b0" BEGIN VALUE "Comments", "http://sqlite.phxsoftware.com" VALUE "FileDescription", "System.Data.SQLite Interop Library" VALUE "FileVersion", "1.0.50.0" VALUE "InternalName", "SQLite.Interop.DLL" VALUE "LegalCopyright", "Released to the public domain" VALUE "OriginalFilename", "SQLite3.DLL 3.5.9" VALUE "ProductName", "System.Data.SQLite" VALUE "ProductVersion", "1.0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x409, 1200 |
|
|
|
|
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
..
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
///////////////////////////////////////////////////////////////////////////// // // Version // VS_VERSION_INFO VERSIONINFO FILEVERSION 1,0,52,0 PRODUCTVERSION 1,0,0,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L #else FILEFLAGS 0x0L #endif ................................................................................ BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904b0" BEGIN VALUE "Comments", "http://sqlite.phxsoftware.com" VALUE "FileDescription", "System.Data.SQLite Interop Library" VALUE "FileVersion", "1.0.52.0" VALUE "InternalName", "SQLite.Interop.DLL" VALUE "LegalCopyright", "Released to the public domain" VALUE "OriginalFilename", "SQLite3.DLL 3.6.0" VALUE "ProductName", "System.Data.SQLite" VALUE "ProductVersion", "1.0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x409, 1200 |
Changes to SQLite.Interop/SQLite.Interop.vcproj.
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 ... 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 ... 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 ... 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 ... 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 ... 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 ... 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 ... 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 |
Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" StringPooling="true" ExceptionHandling="0" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool ................................................................................ Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" ExecutionBucket="7" Optimization="1" FavorSizeOrSpeed="2" PreprocessorDefinitions="_WIN32_WCE=$(CEVER);UNDER_CE=$(CEVER);WINCE;$(PLATFORMDEFINES);NDEBUG;_WINDOWS;_USRDLL;CPPSMART_EXPORTS;$(ARCHFAM);$(_ARCHFAM_);UNICODE;_UNICODE;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" ExceptionHandling="0" BufferSecurityCheck="false" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool Name="VCResourceCompilerTool" PreprocessorDefinitions="NDEBUG;_UNICODE;UNICODE;_WIN32_WCE;UNDER_CE" ................................................................................ TargetEnvironment="2" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" StringPooling="true" ExceptionHandling="0" BufferSecurityCheck="false" EnableFunctionLevelLinking="true" RuntimeTypeInfo="false" /> <Tool ................................................................................ TargetEnvironment="3" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" StringPooling="true" ExceptionHandling="0" BufferSecurityCheck="false" EnableFunctionLevelLinking="true" RuntimeTypeInfo="false" /> <Tool ................................................................................ <Tool Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> ................................................................................ TargetEnvironment="1" /> <Tool Name="VCCLCompilerTool" ExecutionBucket="7" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_WIN32_WCE=$(CEVER);UNDER_CE=$(CEVER);WINCE;$(PLATFORMDEFINES);_DEBUG;_WINDOWS;_USRDLL;CPPSMART_EXPORTS;$(ARCHFAM);$(_ARCHFAM_);UNICODE;_UNICODE;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool Name="VCResourceCompilerTool" ................................................................................ Name="VCMIDLTool" TargetEnvironment="2" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> ................................................................................ Name="VCMIDLTool" TargetEnvironment="3" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> |
| | > > | | | | | | |
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 ... 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 ... 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 ... 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 ... 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 ... 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 ... 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 ... 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 |
Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" StringPooling="true" ExceptionHandling="0" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool ................................................................................ Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" ExecutionBucket="7" Optimization="1" FavorSizeOrSpeed="2" PreprocessorDefinitions="_WIN32_WCE=$(CEVER);UNDER_CE=$(CEVER);WINCE;$(PLATFORMDEFINES);NDEBUG;_WINDOWS;_USRDLL;CPPSMART_EXPORTS;$(ARCHFAM);$(_ARCHFAM_);UNICODE;_UNICODE;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" StringPooling="true" ExceptionHandling="0" BufferSecurityCheck="false" EnableFunctionLevelLinking="true" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool Name="VCResourceCompilerTool" PreprocessorDefinitions="NDEBUG;_UNICODE;UNICODE;_WIN32_WCE;UNDER_CE" ................................................................................ TargetEnvironment="2" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" StringPooling="true" ExceptionHandling="0" BufferSecurityCheck="false" EnableFunctionLevelLinking="true" RuntimeTypeInfo="false" /> <Tool ................................................................................ TargetEnvironment="3" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="2" FavorSizeOrSpeed="1" PreprocessorDefinitions="NDEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" StringPooling="true" ExceptionHandling="0" BufferSecurityCheck="false" EnableFunctionLevelLinking="true" RuntimeTypeInfo="false" /> <Tool ................................................................................ <Tool Name="VCMIDLTool" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> ................................................................................ TargetEnvironment="1" /> <Tool Name="VCCLCompilerTool" ExecutionBucket="7" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_WIN32_WCE=$(CEVER);UNDER_CE=$(CEVER);WINCE;$(PLATFORMDEFINES);_DEBUG;_WINDOWS;_USRDLL;CPPSMART_EXPORTS;$(ARCHFAM);$(_ARCHFAM_);UNICODE;_UNICODE;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> <Tool Name="VCResourceCompilerTool" ................................................................................ Name="VCMIDLTool" TargetEnvironment="2" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> ................................................................................ Name="VCMIDLTool" TargetEnvironment="3" /> <Tool Name="VCCLCompilerTool" AdditionalOptions="/GS-" Optimization="0" PreprocessorDefinitions="_DEBUG;_WINDOWS;_USRDLL;_CRT_SECURE_NO_DEPRECATE;NO_TCL;THREADSAFE=1;WIN64;SQLITE_HAS_CODEC;SQLITE_ENABLE_COLUMN_METADATA;SQLITE_ENABLE_FTS3;SQLITE_OMIT_TRACE;SQLITE_ENABLE_RTREE" RuntimeLibrary="3" RuntimeTypeInfo="false" DebugInformationFormat="3" /> <Tool Name="VCManagedResourceCompilerTool" /> |
Changes to SQLite.Interop/crypt.c.
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
...
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
|
return rc; } // Once a password has been supplied and a key created, we don't keep the // original password for security purposes. Therefore return NULL. void sqlite3CodecGetKey(sqlite3 *db, int nDb, void **ppKey, int *pnKeyLen) { *ppKey = NULL; *pnKeyLen = 0; } // We do not attach this key to the temp store, only the main database. __declspec(dllexport) int WINAPI sqlite3_key_interop(sqlite3 *db, const void *pKey, int nKeySize) { return sqlite3CodecAttach(db, 0, pKey, nKeySize); } ................................................................................ // Start a transaction rc = sqlite3BtreeBeginTrans(pbt, 1); if (!rc) { // Rewrite all the pages in the database using the new encryption key Pgno nPage = sqlite3PagerPagecount(p); Pgno nSkip = PAGER_MJ_PGNO(p); DbPage *pPage; Pgno n; for(n = 1; rc == SQLITE_OK && n <= nPage; n ++) { if (n == nSkip) continue; rc = sqlite3PagerGet(p, n, &pPage); if(!rc) { |
>
>
>
>
|
|
|
>
>
|
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
...
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
|
return rc; } // Once a password has been supplied and a key created, we don't keep the // original password for security purposes. Therefore return NULL. void sqlite3CodecGetKey(sqlite3 *db, int nDb, void **ppKey, int *pnKeyLen) { Btree *pbt = db->aDb[0].pBt; Pager *p = sqlite3BtreePager(pbt); LPCRYPTBLOCK pBlock = (LPCRYPTBLOCK)sqlite3pager_get_codecarg(p); if (ppKey) *ppKey = 0; if (pnKeyLen && pBlock) *pnKeyLen = 1; } // We do not attach this key to the temp store, only the main database. __declspec(dllexport) int WINAPI sqlite3_key_interop(sqlite3 *db, const void *pKey, int nKeySize) { return sqlite3CodecAttach(db, 0, pKey, nKeySize); } ................................................................................ // Start a transaction rc = sqlite3BtreeBeginTrans(pbt, 1); if (!rc) { // Rewrite all the pages in the database using the new encryption key Pgno nPage; Pgno nSkip = PAGER_MJ_PGNO(p); DbPage *pPage; Pgno n; rc = sqlite3PagerPagecount(p, &nPage); for(n = 1; rc == SQLITE_OK && n <= nPage; n ++) { if (n == nSkip) continue; rc = sqlite3PagerGet(p, n, &pPage); if(!rc) { |
Changes to SQLite.Interop/interop.c.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ... 787 788 789 790 791 792 793 794 795 796 797 798 799 800 ... 908 909 910 911 912 913 914 915 916 |
#if _WIN32_WCE #include "merge.h" #else #include "merge_full.h" #endif // _WIN32_WCE #endif // NDEBUG #ifdef OS_WIN // Additional flag for sqlite3.flags, we use it as a reference counter #define SQLITE_WantClose 0x10000000 typedef void (WINAPI *SQLITEUSERFUNC)(void *, int, void **); typedef int (WINAPI *SQLITECOLLATION)(int, const void *, int, const void*); ................................................................................ n = sqlite3_table_column_metadata(db, zDbName, zTableName, zColumnName, pzDataType, pzCollSeq, pNotNull, pPrimaryKey, pAutoinc); *pdtLen = (*pzDataType != 0) ? strlen(*pzDataType) : 0; *pcsLen = (*pzCollSeq != 0) ? strlen(*pzCollSeq) : 0; return n; } void sqlite3_update_callback(void *pArg, int type, const char *pDatabase, const char *pTable, sqlite_int64 rowid) { SQLITEUPDATEHOOK func = (SQLITEUPDATEHOOK)pArg; func(type, pDatabase, strlen(pDatabase), pTable, strlen(pTable), rowid); } ................................................................................ // IMPORTANT: This placeholder is here for a reason!!! // On the Compact Framework the .data section of the DLL must have its RawDataSize larger than the VirtualSize! // If its not, strong name validation will fail and other bad things will happen. //#if _WIN32_WCE //__int64 _ph[17] = {1}; //#endif // _WIN32_WCE #endif // OS_WIN |
| > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | |
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ... 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 ... 975 976 977 978 979 980 981 982 983 |
#if _WIN32_WCE #include "merge.h" #else #include "merge_full.h" #endif // _WIN32_WCE #endif // NDEBUG #ifdef SQLITE_OS_WIN // Additional flag for sqlite3.flags, we use it as a reference counter #define SQLITE_WantClose 0x10000000 typedef void (WINAPI *SQLITEUSERFUNC)(void *, int, void **); typedef int (WINAPI *SQLITECOLLATION)(int, const void *, int, const void*); ................................................................................ n = sqlite3_table_column_metadata(db, zDbName, zTableName, zColumnName, pzDataType, pzCollSeq, pNotNull, pPrimaryKey, pAutoinc); *pdtLen = (*pzDataType != 0) ? strlen(*pzDataType) : 0; *pcsLen = (*pzCollSeq != 0) ? strlen(*pzCollSeq) : 0; return n; } __declspec(dllexport) int WINAPI sqlite3_table_hascheckconstraints(sqlite3 *db, const char *zDbName, const char *zTableName, int *result) { int rc; char *zErrMsg = 0; Table *pTab = 0; *result = 0; /* Ensure the database schema has been loaded */ sqlite3_mutex_enter(db->mutex); (void)sqlite3SafetyOn(db); sqlite3BtreeEnterAll(db); rc = sqlite3Init(db, &zErrMsg); sqlite3BtreeLeaveAll(db); if( SQLITE_OK!=rc ){ goto error_out; } /* Locate the table in question */ pTab = sqlite3FindTable(db, zTableName, zDbName); if( !pTab || pTab->pSelect ){ pTab = 0; goto error_out; } if (pTab->pCheck) *result = 1; error_out: (void)sqlite3SafetyOff(db); if( !pTab ){ sqlite3SetString(&zErrMsg, db, "no such table : ", zTableName, 0); rc = SQLITE_ERROR; } sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg); sqlite3_free(zErrMsg); rc = sqlite3ApiExit(db, rc); sqlite3_mutex_leave(db->mutex); return rc; } __declspec(dllexport) int WINAPI sqlite3_index_column_info_interop(sqlite3 *db, const char *zDb, const char *zIndexName, const char *zColumnName, int *sortOrder, int *onError, char **pzColl, int *plen) { Index *pIdx; Table *pTab; char *zErrMsg = 0; int n; pIdx = sqlite3FindIndex(db, zIndexName, zDb); if (!pIdx) return SQLITE_ERROR; pTab = pIdx->pTable; for (n = 0; n < pIdx->nColumn; n++) { int cnum = pIdx->aiColumn[n]; if (sqlite3StrICmp(pTab->aCol[cnum].zName, zColumnName) == 0) { *sortOrder = pIdx->aSortOrder[n]; *pzColl = pIdx->azColl[n]; *plen = strlen(*pzColl); *onError = pIdx->onError; return SQLITE_OK; } } return SQLITE_ERROR; } void sqlite3_update_callback(void *pArg, int type, const char *pDatabase, const char *pTable, sqlite_int64 rowid) { SQLITEUPDATEHOOK func = (SQLITEUPDATEHOOK)pArg; func(type, pDatabase, strlen(pDatabase), pTable, strlen(pTable), rowid); } ................................................................................ // IMPORTANT: This placeholder is here for a reason!!! // On the Compact Framework the .data section of the DLL must have its RawDataSize larger than the VirtualSize! // If its not, strong name validation will fail and other bad things will happen. //#if _WIN32_WCE //__int64 _ph[17] = {1}; //#endif // _WIN32_WCE #endif // SQLITE_OS_WIN |
Changes to SQLite.Interop/merge.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// This code was automatically generated from assembly
// C:\Src\SQLite.NET\System.Data.SQLite\bin\CompactFramework\System.Data.SQLite.dll
#include <windef.h>
#pragma data_seg(push,clrseg,".clr")
#pragma comment(linker, "/SECTION:.clr,ER")
char __ph[132720] = {0}; // The number of bytes to reserve
#pragma data_seg(pop,clrseg)
typedef BOOL (WINAPI *DLLMAIN)(HANDLE, DWORD, LPVOID);
typedef struct EXTRA_STUFF
{
DWORD dwNativeEntryPoint;
} EXTRA_STUFF, *LPEXTRA_STUFF;
|
| |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// This code was automatically generated from assembly
// C:\Src\SQLite.NET\System.Data.SQLite\bin\CompactFramework\System.Data.SQLite.dll
#include <windef.h>
#pragma data_seg(push,clrseg,".clr")
#pragma comment(linker, "/SECTION:.clr,ER")
char __ph[137456] = {0}; // The number of bytes to reserve
#pragma data_seg(pop,clrseg)
typedef BOOL (WINAPI *DLLMAIN)(HANDLE, DWORD, LPVOID);
typedef struct EXTRA_STUFF
{
DWORD dwNativeEntryPoint;
} EXTRA_STUFF, *LPEXTRA_STUFF;
|
Changes to SQLite.Interop/merge_full.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// This code was automatically generated from assembly
// C:\Src\SQLite.NET\System.Data.SQLite\bin\System.Data.SQLite.dll
#include <windef.h>
#pragma data_seg(push,clrseg,".clr")
#pragma comment(linker, "/SECTION:.clr,ER")
char __ph[144728] = {0}; // The number of bytes to reserve
#pragma data_seg(pop,clrseg)
typedef BOOL (WINAPI *DLLMAIN)(HANDLE, DWORD, LPVOID);
typedef struct EXTRA_STUFF
{
DWORD dwNativeEntryPoint;
} EXTRA_STUFF, *LPEXTRA_STUFF;
|
| |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// This code was automatically generated from assembly
// C:\Src\SQLite.NET\System.Data.SQLite\bin\System.Data.SQLite.dll
#include <windef.h>
#pragma data_seg(push,clrseg,".clr")
#pragma comment(linker, "/SECTION:.clr,ER")
char __ph[149816] = {0}; // The number of bytes to reserve
#pragma data_seg(pop,clrseg)
typedef BOOL (WINAPI *DLLMAIN)(HANDLE, DWORD, LPVOID);
typedef struct EXTRA_STUFF
{
DWORD dwNativeEntryPoint;
} EXTRA_STUFF, *LPEXTRA_STUFF;
|
Changes to SQLite.Interop/src/sqlite3.c.
more than 10,000 changes
Changes to SQLite.Interop/src/sqlite3.def.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
..
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
EXPORTS
sqlite3_aggregate_context
sqlite3_aggregate_count
sqlite3_bind_blob
sqlite3_bind_double
sqlite3_bind_int
sqlite3_bind_int64
sqlite3_bind_null
sqlite3_bind_parameter_count
sqlite3_bind_parameter_index
sqlite3_bind_parameter_name
sqlite3_bind_text
sqlite3_bind_text16
sqlite3_busy_handler
sqlite3_busy_timeout
sqlite3_changes
sqlite3_close
sqlite3_collation_needed
sqlite3_collation_needed16
sqlite3_column_blob
sqlite3_column_bytes
sqlite3_column_bytes16
sqlite3_column_count
................................................................................
sqlite3_column_int
sqlite3_column_int64
sqlite3_column_name
sqlite3_column_name16
sqlite3_column_text
sqlite3_column_text16
sqlite3_column_type
sqlite3_commit_hook
sqlite3_complete
sqlite3_complete16
sqlite3_create_collation
sqlite3_create_collation16
sqlite3_create_function
sqlite3_create_function16
sqlite3_data_count
sqlite3_db_handle
sqlite3_enable_shared_cache
sqlite3_errcode
sqlite3_errmsg
sqlite3_errmsg16
sqlite3_exec
sqlite3_expired
sqlite3_finalize
sqlite3_free
sqlite3_free_table
sqlite3_get_autocommit
sqlite3_get_auxdata
sqlite3_get_table
sqlite3_global_recover
sqlite3_interrupt
sqlite3_last_insert_rowid
sqlite3_libversion
sqlite3_libversion_number
sqlite3_mprintf
sqlite3_open
sqlite3_open16
sqlite3_prepare
sqlite3_prepare16
sqlite3_progress_handler
sqlite3_reset
sqlite3_result_blob
sqlite3_result_double
sqlite3_result_error
sqlite3_result_error16
sqlite3_result_int
sqlite3_result_int64
sqlite3_result_null
sqlite3_result_text
sqlite3_result_text16
sqlite3_result_text16be
sqlite3_result_text16le
sqlite3_result_value
sqlite3_rollback_hook
sqlite3_set_authorizer
sqlite3_set_auxdata
sqlite3_snprintf
sqlite3_step
sqlite3_thread_cleanup
sqlite3_total_changes
sqlite3_transfer_bindings
sqlite3_update_hook
sqlite3_user_data
sqlite3_value_blob
sqlite3_value_bytes
sqlite3_value_bytes16
sqlite3_value_double
sqlite3_value_int
sqlite3_value_int64
sqlite3_value_text
sqlite3_value_text16
sqlite3_value_text16be
sqlite3_value_text16le
sqlite3_value_type
sqlite3_vmprintf
sqlite3_key
sqlite3_rekey
|
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
<
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
..
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
EXPORTS sqlite3_aggregate_context sqlite3_aggregate_count sqlite3_auto_extension sqlite3_bind_blob sqlite3_bind_double sqlite3_bind_int sqlite3_bind_int64 sqlite3_bind_null sqlite3_bind_parameter_count sqlite3_bind_parameter_index sqlite3_bind_parameter_name sqlite3_bind_text sqlite3_bind_text16 sqlite3_bind_value sqlite3_bind_zeroblob sqlite3_blob_bytes sqlite3_blob_close sqlite3_blob_open sqlite3_blob_read sqlite3_blob_write sqlite3_busy_handler sqlite3_busy_timeout sqlite3_changes sqlite3_clear_bindings sqlite3_close sqlite3_collation_needed sqlite3_collation_needed16 sqlite3_column_blob sqlite3_column_bytes sqlite3_column_bytes16 sqlite3_column_count ................................................................................ sqlite3_column_int sqlite3_column_int64 sqlite3_column_name sqlite3_column_name16 sqlite3_column_text sqlite3_column_text16 sqlite3_column_type sqlite3_column_value sqlite3_commit_hook sqlite3_complete sqlite3_complete16 sqlite3_create_collation sqlite3_create_collation16 sqlite3_create_collation_v2 sqlite3_create_function sqlite3_create_function16 sqlite3_create_module sqlite3_create_module_v2 sqlite3_data_count sqlite3_db_handle sqlite3_declare_vtab sqlite3_enable_load_extension sqlite3_enable_shared_cache sqlite3_errcode sqlite3_errmsg sqlite3_errmsg16 sqlite3_exec sqlite3_expired sqlite3_extended_result_codes sqlite3_file_control sqlite3_finalize sqlite3_free sqlite3_free_table sqlite3_get_autocommit sqlite3_get_auxdata sqlite3_get_table sqlite3_global_recover sqlite3_interrupt sqlite3_last_insert_rowid sqlite3_libversion sqlite3_libversion_number sqlite3_load_extension sqlite3_malloc sqlite3_memory_alarm sqlite3_memory_highwater sqlite3_memory_used sqlite3_mprintf sqlite3_mutex_alloc sqlite3_mutex_enter sqlite3_mutex_free sqlite3_mutex_leave sqlite3_mutex_try sqlite3_open sqlite3_open16 sqlite3_open_v2 sqlite3_overload_function sqlite3_prepare sqlite3_prepare16 sqlite3_prepare16_v2 sqlite3_prepare_v2 ;sqlite3_profile sqlite3_progress_handler sqlite3_randomness sqlite3_realloc sqlite3_release_memory sqlite3_reset sqlite3_reset_auto_extension sqlite3_result_blob sqlite3_result_double sqlite3_result_error sqlite3_result_error16 sqlite3_result_error_code sqlite3_result_error_nomem sqlite3_result_error_toobig sqlite3_result_int sqlite3_result_int64 sqlite3_result_null sqlite3_result_text sqlite3_result_text16 sqlite3_result_text16be sqlite3_result_text16le sqlite3_result_value sqlite3_result_zeroblob sqlite3_rollback_hook sqlite3_set_authorizer sqlite3_set_auxdata sqlite3_sleep sqlite3_snprintf sqlite3_soft_heap_limit sqlite3_sql sqlite3_step sqlite3_test_control sqlite3_thread_cleanup sqlite3_threadsafe sqlite3_total_changes ;sqlite3_trace sqlite3_transfer_bindings sqlite3_update_hook sqlite3_user_data sqlite3_value_blob sqlite3_value_bytes sqlite3_value_bytes16 sqlite3_value_double sqlite3_value_int sqlite3_value_int64 sqlite3_value_numeric_type sqlite3_value_text sqlite3_value_text16 sqlite3_value_text16be sqlite3_value_text16le sqlite3_value_type sqlite3_vfs_find sqlite3_vfs_register sqlite3_vfs_unregister sqlite3_vmprintf sqlite3_key sqlite3_rekey |
Changes to SQLite.Interop/src/sqlite3.h.
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 .. 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 .. 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 ... 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 ... 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 ... 466 467 468 469 470 471 472 473 474 475 476 477 478 479 ... 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 ... 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 ... 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 ... 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 ... 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 ... 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 .... 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 .... 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 .... 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 .... 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 .... 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 .... 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 .... 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 .... 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 .... 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 .... 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 .... 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 .... 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 .... 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 .... 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 .... 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 .... 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 .... 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 .... 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 .... 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 .... 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 .... 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 .... 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 .... 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 .... 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 .... 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 .... 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 .... 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 .... 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 .... 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 .... 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 .... 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 .... 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 .... 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 .... 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 .... 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 .... 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 .... 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 .... 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 .... 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 .... 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 .... 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 .... 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 .... 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 .... 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 .... 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 .... 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 .... 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 .... 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 .... 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 .... 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 .... 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 .... 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 .... 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 .... 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 .... 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 .... 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 .... 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 .... 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 .... 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 .... 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 .... 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 .... 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 .... 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 .... 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 .... 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 .... 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 .... 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 |
** presents to client programs. If a C-function, structure, datatype, ** or constant definition does not appear in this file, then it is ** not a published API of SQLite, is subject to change without ** notice, and should not be referenced by programs that use SQLite. ** ** Some of the definitions that are in this file are marked as ** "experimental". Experimental interfaces are normally new ** features recently added to SQLite. We do not anticipate changes ** to experimental interfaces but reserve to make minor changes if ** experience from use "in the wild" suggest such changes are prudent. ** ** The official C-language API documentation for SQLite is derived ** from comments in this file. This file is the authoritative source ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** ** @(#) $Id: sqlite3.h,v 1.34 2008/05/28 08:25:00 rmsimpson Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. ................................................................................ ** Add the ability to override 'extern' */ #ifndef SQLITE_EXTERN # define SQLITE_EXTERN extern #endif /* ** Make sure these symbols where not defined by some previous header ** file. */ #ifdef SQLITE_VERSION # undef SQLITE_VERSION #endif #ifdef SQLITE_VERSION_NUMBER # undef SQLITE_VERSION_NUMBER #endif ................................................................................ ** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in ** the sqlite3.h file specify the version of SQLite with which ** that header file is associated. ** ** The "version" of SQLite is a string of the form "X.Y.Z". ** The phrase "alpha" or "beta" might be appended after the Z. ** The X value is major version number always 3 in SQLite3. ** The X value only changes when backwards compatibility is ** broken and we intend to never break ** backwards compatibility. The Y value is the minor version ** number and only changes when ** there are major feature enhancements that are forwards compatible ** but not backwards compatible. The Z value is release number ** and is incremented with ** each release but resets back to 0 when Y is incremented. ** ** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. ** ** INVARIANTS: ** ** {F10011} The SQLITE_VERSION #define in the sqlite3.h header file ** evaluates to a string literal that is the SQLite version ** with which the header file is associated. ** ** {F10014} The SQLITE_VERSION_NUMBER #define resolves to an integer ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and ** Z are the major version, minor version, and release number. */ #define SQLITE_VERSION "3.5.9" #define SQLITE_VERSION_NUMBER 3005009 /* ** CAPI3REF: Run-Time Library Version Numbers {F10020} ** KEYWORDS: sqlite3_version ** ** These features provide the same information as the [SQLITE_VERSION] ** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated ** with the library instead of the header file. Cautious programmers might ** include a check in their application to verify that ** sqlite3_libversion_number() always returns the value ** [SQLITE_VERSION_NUMBER]. ** ** The sqlite3_libversion() function returns the same information as is ** in the sqlite3_version[] string constant. The function is provided ** for use in DLLs since DLL users usually do not have direct access to string ** constants within the DLL. ** ** INVARIANTS: ** ** {F10021} The [sqlite3_libversion_number()] interface returns an integer ** equal to [SQLITE_VERSION_NUMBER]. ** ** {F10022} The [sqlite3_version] string constant contains the text of the ** [SQLITE_VERSION] string. ** ** {F10023} The [sqlite3_libversion()] function returns ** a pointer to the [sqlite3_version] string constant. */ SQLITE_EXTERN const char sqlite3_version[]; const char *sqlite3_libversion(void); int sqlite3_libversion_number(void); /* ** CAPI3REF: Test To See If The Library Is Threadsafe {F10100} ** ** SQLite can be compiled with or without mutexes. When ** the SQLITE_THREADSAFE C preprocessor macro is true, mutexes ** are enabled and SQLite is threadsafe. When that macro is false, ** the mutexes are omitted. Without the mutexes, it is not safe ** to use SQLite from more than one thread. ** ** There is a measurable performance penalty for enabling mutexes. ** So if speed is of utmost importance, it makes sense to disable ** the mutexes. But for maximum safety, mutexes should be enabled. ** The default behavior is for mutexes to be enabled. ** ** This interface can be used by a program to make sure that the ** version of SQLite that it is linking against was compiled with ** the desired setting of the SQLITE_THREADSAFE macro. ** ** INVARIANTS: ** ** {F10101} The [sqlite3_threadsafe()] function returns nonzero if ** SQLite was compiled with its mutexes enabled or zero ** if SQLite was compiled with mutexes disabled. */ int sqlite3_threadsafe(void); /* ** CAPI3REF: Database Connection Handle {F12000} ** KEYWORDS: {database connection} {database connections} ** ** Each open SQLite database is represented by pointer to an instance of the ** opaque structure named "sqlite3". It is useful to think of an sqlite3 ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces are its constructors ** and [sqlite3_close()] is its destructor. There are many other interfaces ** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and ** [sqlite3_busy_timeout()] to name but three) that are methods on this ** object. */ typedef struct sqlite3 sqlite3; /* ** CAPI3REF: 64-Bit Integer Types {F10200} ** KEYWORDS: sqlite_int64 sqlite_uint64 ** ** Because there is no cross-platform way to specify 64-bit integer types ** SQLite includes typedefs for 64-bit signed and unsigned integers. ** ** The sqlite3_int64 and sqlite3_uint64 are the preferred type ** definitions. The sqlite_int64 and sqlite_uint64 types are ** supported for backwards compatibility only. ** ** INVARIANTS: ** ** {F10201} The [sqlite_int64] and [sqlite3_int64] types specify a ** 64-bit signed integer. ** ** {F10202} The [sqlite_uint64] and [sqlite3_uint64] types specify ** a 64-bit unsigned integer. */ #ifdef SQLITE_INT64_TYPE typedef SQLITE_INT64_TYPE sqlite_int64; typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; #elif defined(_MSC_VER) || defined(__BORLANDC__) typedef __int64 sqlite_int64; ................................................................................ typedef unsigned long long int sqlite_uint64; #endif typedef sqlite_int64 sqlite3_int64; typedef sqlite_uint64 sqlite3_uint64; /* ** If compiling for a processor that lacks floating point support, ** substitute integer for floating-point */ #ifdef SQLITE_OMIT_FLOATING_POINT # define double sqlite3_int64 #endif /* ** CAPI3REF: Closing A Database Connection {F12010} ** ** This routine is the destructor for the [sqlite3] object. ** ** Applications should [sqlite3_finalize | finalize] all ** [prepared statements] and ** [sqlite3_blob_close | close] all [sqlite3_blob | BLOBs] ** associated with the [sqlite3] object prior ** to attempting to close the [sqlite3] object. ** ** <todo>What happens to pending transactions? Are they ** rolled back, or abandoned?</todo> ** ** INVARIANTS: ** ** {F12011} The [sqlite3_close()] interface destroys an [sqlite3] object ** allocated by a prior call to [sqlite3_open()], ** [sqlite3_open16()], or [sqlite3_open_v2()]. ** ** {F12012} The [sqlite3_close()] function releases all memory used by the ** connection and closes all open files. ** ** {F12013} If the database connection contains ** [prepared statements] that have not been ** finalized by [sqlite3_finalize()], then [sqlite3_close()] ** returns [SQLITE_BUSY] and leaves the connection open. ** ** {F12014} Giving sqlite3_close() a NULL pointer is a harmless no-op. ** ** LIMITATIONS: ** ** {U12015} The parameter to [sqlite3_close()] must be an [sqlite3] object ** pointer previously obtained from [sqlite3_open()] or the ** equivalent, or NULL. ** ** {U12016} The parameter to [sqlite3_close()] must not have been previously ** closed. */ int sqlite3_close(sqlite3 *); /* ** The type for a callback function. ** This is legacy and deprecated. It is included for historical ** compatibility and is not documented. */ typedef int (*sqlite3_callback)(void*,int,char**, char**); /* ** CAPI3REF: One-Step Query Execution Interface {F12100} ** ** The sqlite3_exec() interface is a convenient way of running ** one or more SQL statements without a lot of C code. The ** SQL statements are passed in as the second parameter to ** sqlite3_exec(). The statements are evaluated one by one ** until either an error or an interrupt is encountered or ** until they are all done. The 3rd parameter is an optional ** callback that is invoked once for each row of any query results ** produced by the SQL statements. The 5th parameter tells where ** to write any error messages. ** ** The sqlite3_exec() interface is implemented in terms of ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()]. ** The sqlite3_exec() routine does nothing that cannot be done ** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()]. ** The sqlite3_exec() is just a convenient wrapper. ** ** INVARIANTS: ** ** {F12101} The [sqlite3_exec()] interface evaluates zero or more UTF-8 ** encoded, semicolon-separated, SQL statements in the ** zero-terminated string of its 2nd parameter within the ** context of the [sqlite3] object given in the 1st parameter. ** ** {F12104} The return value of [sqlite3_exec()] is SQLITE_OK if all ** SQL statements run successfully. ** ** {F12105} The return value of [sqlite3_exec()] is an appropriate ** non-zero error code if any SQL statement fails. ** ** {F12107} If one or more of the SQL statements handed to [sqlite3_exec()] ** return results and the 3rd parameter is not NULL, then ** the callback function specified by the 3rd parameter is ** invoked once for each row of result. ** ** {F12110} If the callback returns a non-zero value then [sqlite3_exec()] ** will aborted the SQL statement it is currently evaluating, ** skip all subsequent SQL statements, and return [SQLITE_ABORT]. ** <todo>What happens to *errmsg here? Does the result code for ** sqlite3_errcode() get set?</todo> ** ** {F12113} The [sqlite3_exec()] routine will pass its 4th parameter through ** as the 1st parameter of the callback. ** ** {F12116} The [sqlite3_exec()] routine sets the 2nd parameter of its ** callback to be the number of columns in the current row of ** result. ** ** {F12119} The [sqlite3_exec()] routine sets the 3rd parameter of its ** callback to be an array of pointers to strings holding the ** values for each column in the current result set row as ** obtained from [sqlite3_column_text()]. ** ** {F12122} The [sqlite3_exec()] routine sets the 4th parameter of its ** callback to be an array of pointers to strings holding the ** names of result columns as obtained from [sqlite3_column_name()]. ** ** {F12125} If the 3rd parameter to [sqlite3_exec()] is NULL then ** [sqlite3_exec()] never invokes a callback. All query ** results are silently discarded. ** ** {F12128} If an error occurs while parsing or evaluating any of the SQL ** statements handed to [sqlite3_exec()] then [sqlite3_exec()] will ** return an [error code] other than [SQLITE_OK]. ** ** {F12131} If an error occurs while parsing or evaluating any of the SQL ** handed to [sqlite3_exec()] and if the 5th parameter (errmsg) ** to [sqlite3_exec()] is not NULL, then an error message is ** allocated using the equivalent of [sqlite3_mprintf()] and ** *errmsg is made to point to that message. ** ** {F12134} The [sqlite3_exec()] routine does not change the value of ** *errmsg if errmsg is NULL or if there are no errors. ** ** {F12137} The [sqlite3_exec()] function sets the error code and message ** accessible via [sqlite3_errcode()], [sqlite3_errmsg()], and ** [sqlite3_errmsg16()]. ** ** LIMITATIONS: ** ** {U12141} The first parameter to [sqlite3_exec()] must be an valid and open ** [database connection]. ** ** {U12142} The database connection must not be closed while ** [sqlite3_exec()] is running. ** ** {U12143} The calling function is should use [sqlite3_free()] to free ** the memory that *errmsg is left pointing at once the error ** message is no longer needed. ** ** {U12145} The SQL statement text in the 2nd parameter to [sqlite3_exec()] ** must remain unchanged while [sqlite3_exec()] is running. */ int sqlite3_exec( sqlite3*, /* An open database */ const char *sql, /* SQL to be evaluted */ int (*callback)(void*,int,char**,char**), /* Callback function */ void *, /* 1st argument to callback */ char **errmsg /* Error msg written here */ ); /* ** CAPI3REF: Result Codes {F10210} ** KEYWORDS: SQLITE_OK {error code} {error codes} ** ** Many SQLite functions return an integer result code from the set shown ** here in order to indicates success or failure. ** ** See also: [SQLITE_IOERR_READ | extended result codes] */ #define SQLITE_OK 0 /* Successful result */ /* beginning-of-error-codes */ #define SQLITE_ERROR 1 /* SQL error or missing database */ #define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ ................................................................................ #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* end-of-error-codes */ /* ** CAPI3REF: Extended Result Codes {F10220} ** KEYWORDS: {extended error code} {extended error codes} ** KEYWORDS: {extended result codes} ** ** In its default configuration, SQLite API routines return one of 26 integer ** [SQLITE_OK | result codes]. However, experience has shown that ** many of these result codes are too course-grained. They do not provide as ** much information about problems as programmers might like. In an effort to ** address this, newer versions of SQLite (version 3.3.8 and later) include ** support for additional result codes that provide more detailed information ** about errors. The extended result codes are enabled or disabled ** for each database connection using the [sqlite3_extended_result_codes()] ** API. ** ** Some of the available extended result codes are listed here. ** One may expect the number of extended result codes will be expand ** over time. Software that uses extended result codes should expect ** to see new result codes in future releases of SQLite. ** ** The SQLITE_OK result code will never be extended. It will always ** be exactly zero. ** ** INVARIANTS: ** ** {F10223} The symbolic name for an extended result code always contains ** a related primary result code as a prefix. ** ** {F10224} Primary result code names contain a single "_" character. ** ** {F10225} Extended result code names contain two or more "_" characters. ** ** {F10226} The numeric value of an extended result code contains the ** numeric value of its corresponding primary result code in ** its least significant 8 bits. */ #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) /* ** CAPI3REF: Flags For File Open Operations {F10230} ** ** These bit values are intended for use in the ** 3rd parameter to the [sqlite3_open_v2()] interface and ** in the 4th parameter to the xOpen method of the ................................................................................ #define SQLITE_OPEN_MAIN_DB 0x00000100 #define SQLITE_OPEN_TEMP_DB 0x00000200 #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 #define SQLITE_OPEN_SUBJOURNAL 0x00002000 #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* ** CAPI3REF: Device Characteristics {F10240} ** ** The xDeviceCapabilities method of the [sqlite3_io_methods] ** object returns an integer which is a vector of the these ** bit values expressing I/O characteristics of the mass storage ................................................................................ ** ** When SQLite invokes the xSync() method of an ** [sqlite3_io_methods] object it uses a combination of ** these integer values as the second argument. ** ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the ** sync operation only needs to flush data to mass storage. Inode ** information need not be flushed. The SQLITE_SYNC_NORMAL flag means ** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means ** to use Mac OS-X style fullsync instead of fsync(). */ #define SQLITE_SYNC_NORMAL 0x00002 #define SQLITE_SYNC_FULL 0x00003 #define SQLITE_SYNC_DATAONLY 0x00010 /* ** CAPI3REF: OS Interface Open File Handle {F11110} ** ** An [sqlite3_file] object represents an open file in the OS ** interface layer. Individual OS interface implementations will ** want to subclass this object by appending additional fields ................................................................................ struct sqlite3_file { const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ }; /* ** CAPI3REF: OS Interface File Virtual Methods Object {F11120} ** ** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to ** an instance of this object. This object defines the ** methods used to perform various operations against the open file. ** ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or ** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). * The second choice is an ** OS-X style fullsync. The SQLITE_SYNC_DATA flag may be ORed in to ** indicate that only the data of the file and not its inode needs to be ** synced. ** ** The integer values to xLock() and xUnlock() are one of ** <ul> ** <li> [SQLITE_LOCK_NONE], ** <li> [SQLITE_LOCK_SHARED], ** <li> [SQLITE_LOCK_RESERVED], ** <li> [SQLITE_LOCK_PENDING], or ** <li> [SQLITE_LOCK_EXCLUSIVE]. ** </ul> ** xLock() increases the lock. xUnlock() decreases the lock. ** The xCheckReservedLock() method looks ** to see if any database connection, either in this ** process or in some other process, is holding an RESERVED, ** PENDING, or EXCLUSIVE lock on the file. It returns true ** if such a lock exists and false if not. ** ** The xFileControl() method is a generic interface that allows custom ** VFS implementations to directly control an open file using the ** [sqlite3_file_control()] interface. The second "op" argument ** is an integer opcode. The third ** argument is a generic pointer which is intended to be a pointer ** to a structure that may contain arguments or space in which to ** write return values. Potential uses for xFileControl() might be ** functions to enable blocking locks with timeouts, to change the ** locking strategy (for example to use dot-file locks), to inquire ** about the status of a lock, or to break stale locks. The SQLite ** core reserves opcodes less than 100 for its own use. ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. ** Applications that define a custom xFileControl method should use opcodes ** greater than 100 to avoid conflicts. ** ** The xSectorSize() method returns the sector size of the ** device that underlies the file. The sector size is the ** minimum write that can be performed without disturbing ** other bytes in the file. The xDeviceCharacteristics() ** method returns a bit vector describing behaviors of the ................................................................................ int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); int (*xSync)(sqlite3_file*, int flags); int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); int (*xLock)(sqlite3_file*, int); int (*xUnlock)(sqlite3_file*, int); int (*xCheckReservedLock)(sqlite3_file*); int (*xFileControl)(sqlite3_file*, int op, void *pArg); int (*xSectorSize)(sqlite3_file*); int (*xDeviceCharacteristics)(sqlite3_file*); /* Additional methods may be added in future releases */ }; /* ** CAPI3REF: Standard File Control Opcodes {F11310} ** ** These integer constants are opcodes for the xFileControl method ** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()] ** interface. ** ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ** opcode causes the xFileControl method to write the current state of ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ** into an integer that the pArg argument points to. This capability ................................................................................ ** Mutexes are created using [sqlite3_mutex_alloc()]. */ typedef struct sqlite3_mutex sqlite3_mutex; /* ** CAPI3REF: OS Interface Object {F11140} ** ** An instance of this object defines the interface between the ** SQLite core and the underlying operating system. The "vfs" ** in the name of the object stands for "virtual file system". ** ** The iVersion field is initially 1 but may be larger for future ** versions of SQLite. Additional fields may be appended to this ** object when the iVersion value is increased. ** ** The szOsFile field is the size of the subclassed [sqlite3_file] ** structure used by this VFS. mxPathname is the maximum length of ** a pathname in this VFS. ** ** Registered sqlite3_vfs objects are kept on a linked list formed by ** the pNext pointer. The [sqlite3_vfs_register()] ** and [sqlite3_vfs_unregister()] interfaces manage this list ** in a thread-safe way. The [sqlite3_vfs_find()] interface ** searches the list. ** ** The pNext field is the only field in the sqlite3_vfs ** structure that SQLite will ever modify. SQLite will only access ** or modify this field while holding a particular static mutex. ** The application should never modify anything within the sqlite3_vfs ** object once the object has been registered. ** ** The zName field holds the name of the VFS module. The name must ** be unique across all VFS modules. ** ** {F11141} SQLite will guarantee that the zFilename string passed to ** xOpen() is a full pathname as generated by xFullPathname() and ** that the string will be valid and unchanged until xClose() is ** called. {END} So the [sqlite3_file] can store a pointer to the ** filename if it needs to remember the filename for some reason. ** ** {F11142} The flags argument to xOpen() includes all bits set in ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] ** or [sqlite3_open16()] is used, then flags includes at least ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END} ** If xOpen() opens a file read-only then it sets *pOutFlags to ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be ** set. ** ** {F11143} SQLite will also add one of the following flags to the xOpen() ** call, depending on the object being opened: ** ** <ul> ** <li> [SQLITE_OPEN_MAIN_DB] ** <li> [SQLITE_OPEN_MAIN_JOURNAL] ** <li> [SQLITE_OPEN_TEMP_DB] ** <li> [SQLITE_OPEN_TEMP_JOURNAL] ** <li> [SQLITE_OPEN_TRANSIENT_DB] ** <li> [SQLITE_OPEN_SUBJOURNAL] ** <li> [SQLITE_OPEN_MASTER_JOURNAL] ** </ul> {END} ** ** The file I/O implementation can use the object type flags to ** changes the way it deals with files. For example, an application ** that does not care about crash recovery or rollback might make ** the open of a journal file a no-op. Writes to this journal would ** also be no-ops, and any attempt to read the journal would return ** SQLITE_IOERR. Or the implementation might recognize that a database ** file will be doing page-aligned sector reads and writes in a random ** order and set up its I/O subsystem accordingly. ** ** SQLite might also add one of the following flags to the xOpen ** method: ** ** <ul> ** <li> [SQLITE_OPEN_DELETEONCLOSE] ** <li> [SQLITE_OPEN_EXCLUSIVE] ** </ul> ** ** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be ** deleted when it is closed. {F11146} The [SQLITE_OPEN_DELETEONCLOSE] ** will be set for TEMP databases, journals and for subjournals. ** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened ** for exclusive access. This flag is set for all files except ** for the main database file. {END} ** ** {F11148} At least szOsFile bytes of memory are allocated by SQLite ** to hold the [sqlite3_file] structure passed as the third ** argument to xOpen. {END} The xOpen method does not have to ** allocate the structure; it should just fill it in. ** ** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] ** to test for the existance of a file, ** or [SQLITE_ACCESS_READWRITE] to test to see ** if a file is readable and writable, or [SQLITE_ACCESS_READ] ** to test to see if a file is at least readable. {END} The file can be a ** directory. ** ** {F11150} SQLite will always allocate at least mxPathname+1 bytes for ** the output buffers for xGetTempname and xFullPathname. {F11151} The exact ** size of the output buffer is also passed as a parameter to both ** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN ** should be returned. As this is handled as a fatal error by SQLite, ** vfs implementations should endeavor to prevent this by setting ** mxPathname to a sufficiently large value. ** ** The xRandomness(), xSleep(), and xCurrentTime() interfaces ** are not strictly a part of the filesystem, but they are ** included in the VFS structure for completeness. ** The xRandomness() function attempts to return nBytes bytes ** of good-quality randomness into zOut. The return value is ** the actual number of bytes of randomness obtained. The ** xSleep() method causes the calling thread to sleep for at ** least the number of microseconds given. The xCurrentTime() ** method returns a Julian Day Number for the current date and ** time. */ typedef struct sqlite3_vfs sqlite3_vfs; struct sqlite3_vfs { int iVersion; /* Structure version number */ int szOsFile; /* Size of subclassed sqlite3_file */ int mxPathname; /* Maximum file pathname length */ sqlite3_vfs *pNext; /* Next registered VFS */ const char *zName; /* Name of this virtual file system */ void *pAppData; /* Pointer to application-specific data */ int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, int flags, int *pOutFlags); int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); int (*xAccess)(sqlite3_vfs*, const char *zName, int flags); int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut); int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol); void (*xDlClose)(sqlite3_vfs*, void*); int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); int (*xSleep)(sqlite3_vfs*, int microseconds); int (*xCurrentTime)(sqlite3_vfs*, double*); /* New fields may be appended in figure versions. The iVersion ** value will increment whenever this happens. */ }; /* ** CAPI3REF: Flags for the xAccess VFS method {F11190} ** ** {F11191} These integer constants can be used as the third parameter to ** the xAccess method of an [sqlite3_vfs] object. {END} They determine ** what kind of permissions the xAccess method is ** looking for. {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method ** simply checks to see if the file exists. {F11193} With ** SQLITE_ACCESS_READWRITE, the xAccess method checks to see ** if the file is both readable and writable. {F11194} With ** SQLITE_ACCESS_READ the xAccess method ** checks to see if the file is readable. */ #define SQLITE_ACCESS_EXISTS 0 #define SQLITE_ACCESS_READWRITE 1 #define SQLITE_ACCESS_READ 2 /* ** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} ** ** The sqlite3_extended_result_codes() routine enables or disables the ** [SQLITE_IOERR_READ | extended result codes] feature of SQLite. ** The extended result codes are disabled by default for historical ** compatibility. ** ** INVARIANTS: ** ** {F12201} Each new [database connection] has the ** [extended result codes] feature ** disabled by default. ** ** {F12202} The [sqlite3_extended_result_codes(D,F)] interface will enable ** [extended result codes] for the ** [database connection] D if the F parameter ** is true, or disable them if F is false. */ int sqlite3_extended_result_codes(sqlite3*, int onoff); /* ** CAPI3REF: Last Insert Rowid {F12220} ** ** Each entry in an SQLite table has a unique 64-bit signed ................................................................................ ** integer key called the "rowid". The rowid is always available ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those ** names are not also used by explicitly declared columns. If ** the table has a column of type INTEGER PRIMARY KEY then that column ** is another alias for the rowid. ** ** This routine returns the rowid of the most recent ** successful INSERT into the database from the database connection ** shown in the first argument. If no successful inserts ** have ever occurred on this database connection, zero is returned. ** ** If an INSERT occurs within a trigger, then the rowid of the ** inserted row is returned by this routine as long as the trigger ** is running. But once the trigger terminates, the value returned ** by this routine reverts to the last value inserted before the ** trigger fired. ** ** An INSERT that fails due to a constraint violation is not a ** successful insert and does not change the value returned by this ** routine. Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, ** and INSERT OR ABORT make no changes to the return value of this ** routine when their insertion fails. When INSERT OR REPLACE ** encounters a constraint violation, it does not fail. The ** INSERT continues to completion after deleting rows that caused ** the constraint problem so INSERT OR REPLACE will always change ** the return value of this interface. ** ** For the purposes of this routine, an insert is considered to ** be successful even if it is subsequently rolled back. ** ** INVARIANTS: ** ** {F12221} The [sqlite3_last_insert_rowid()] function returns the ** rowid of the most recent successful insert done ** on the same database connection and within the same ** trigger context, or zero if there have ** been no qualifying inserts on that connection. ** ** {F12223} The [sqlite3_last_insert_rowid()] function returns ** same value when called from the same trigger context ** immediately before and after a ROLLBACK. ** ** LIMITATIONS: ** ** {U12232} If a separate thread does a new insert on the same ** database connection while the [sqlite3_last_insert_rowid()] ** function is running and thus changes the last insert rowid, ** then the value returned by [sqlite3_last_insert_rowid()] is ** unpredictable and might not equal either the old or the new ** last insert rowid. */ sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); /* ** CAPI3REF: Count The Number Of Rows Modified {F12240} ** ** This function returns the number of database rows that were changed ** or inserted or deleted by the most recently completed SQL statement ** on the connection specified by the first parameter. Only ** changes that are directly specified by the INSERT, UPDATE, or ** DELETE statement are counted. Auxiliary changes caused by ** triggers are not counted. Use the [sqlite3_total_changes()] function ** to find the total number of changes including changes caused by triggers. ** ** A "row change" is a change to a single row of a single table ** caused by an INSERT, DELETE, or UPDATE statement. Rows that ** are changed as side effects of REPLACE constraint resolution, ** rollback, ABORT processing, DROP TABLE, or by any other ................................................................................ ** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does ** not create a new trigger context. ** ** This function returns the number of direct row changes in the ** most recent INSERT, UPDATE, or DELETE statement within the same ** trigger context. ** ** So when called from the top level, this function returns the ** number of changes in the most recent INSERT, UPDATE, or DELETE ** that also occurred at the top level. ** Within the body of a trigger, the sqlite3_changes() interface ** can be called to find the number of ** changes in the most recently completed INSERT, UPDATE, or DELETE ** statement within the body of the same trigger. ** However, the number returned does not include in changes ** caused by subtriggers since they have their own context. ** ** SQLite implements the command "DELETE FROM table" without ** a WHERE clause by dropping and recreating the table. (This is much ** faster than going through and deleting individual elements from the ** table.) Because of this optimization, the deletions in ** "DELETE FROM table" are not row changes and will not be counted ** by the sqlite3_changes() or [sqlite3_total_changes()] functions. ** To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** INVARIANTS: ** ** {F12241} The [sqlite3_changes()] function returns the number of ** row changes caused by the most recent INSERT, UPDATE, ** or DELETE statement on the same database connection and ** within the same trigger context, or zero if there have ** not been any qualifying row changes. ** ** LIMITATIONS: ** ** {U12252} If a separate thread makes changes on the same database connection ** while [sqlite3_changes()] is running then the value returned ** is unpredictable and unmeaningful. */ int sqlite3_changes(sqlite3*); /* ** CAPI3REF: Total Number Of Rows Modified {F12260} *** ** This function returns the number of row changes caused ** by INSERT, UPDATE or DELETE statements since the database handle ** was opened. The count includes all changes from all trigger ** contexts. But the count does not include changes used to ** implement REPLACE constraints, do rollbacks or ABORT processing, ** or DROP table processing. ** The changes ** are counted as soon as the statement that makes them is completed ** (when the statement handle is passed to [sqlite3_reset()] or ** [sqlite3_finalize()]). ** ** SQLite implements the command "DELETE FROM table" without ** a WHERE clause by dropping and recreating the table. (This is much ** faster than going ** through and deleting individual elements from the table.) Because of ** this optimization, the change count for "DELETE FROM table" will be ** zero regardless of the number of elements that were originally in the ** table. To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** See also the [sqlite3_changes()] interface. ** ** INVARIANTS: ** ** {F12261} The [sqlite3_total_changes()] returns the total number ** of row changes caused by INSERT, UPDATE, and/or DELETE ** statements on the same [database connection], in any ** trigger context, since the database connection was ** created. ** ** LIMITATIONS: ** ** {U12264} If a separate thread makes changes on the same database connection ** while [sqlite3_total_changes()] is running then the value ** returned is unpredictable and unmeaningful. */ int sqlite3_total_changes(sqlite3*); /* ** CAPI3REF: Interrupt A Long-Running Query {F12270} ** ** This function causes any pending database operation to abort and ................................................................................ ** return at its earliest opportunity. This routine is typically ** called in response to a user action such as pressing "Cancel" ** or Ctrl-C where the user wants a long query operation to halt ** immediately. ** ** It is safe to call this routine from a thread different from the ** thread that is currently running the database operation. But it ** is not safe to call this routine with a database connection that ** is closed or might close before sqlite3_interrupt() returns. ** ** If an SQL is very nearly finished at the time when sqlite3_interrupt() ** is called, then it might not have an opportunity to be interrupted. ** It might continue to completion. ** An SQL operation that is interrupted will return ** [SQLITE_INTERRUPT]. If the interrupted SQL operation is an ** INSERT, UPDATE, or DELETE that is inside an explicit transaction, ** then the entire transaction will be rolled back automatically. ** A call to sqlite3_interrupt() has no effect on SQL statements ** that are started after sqlite3_interrupt() returns. ** ** INVARIANTS: ** ** {F12271} The [sqlite3_interrupt()] interface will force all running ** SQL statements associated with the same database connection ** to halt after processing at most one additional row of ** data. ** ** {F12272} Any SQL statement that is interrupted by [sqlite3_interrupt()] ** will return [SQLITE_INTERRUPT]. ** ** LIMITATIONS: ** ** {U12279} If the database connection closes while [sqlite3_interrupt()] ** is running then bad things will likely happen. */ void sqlite3_interrupt(sqlite3*); /* ** CAPI3REF: Determine If An SQL Statement Is Complete {F10510} ** ................................................................................ ** appears to be a complete SQL statement. A statement is judged to be ** complete if it ends with a semicolon token and is not a fragment of a ** CREATE TRIGGER statement. Semicolons that are embedded within ** string literals or quoted identifier names or comments are not ** independent tokens (they are part of the token in which they are ** embedded) and thus do not count as a statement terminator. ** ** These routines do not parse the SQL and ** so will not detect syntactically incorrect SQL. ** ** INVARIANTS: ** ** {F10511} The sqlite3_complete() and sqlite3_complete16() functions ** return true (non-zero) if and only if the last ** non-whitespace token in their input is a semicolon that ** is not in between the BEGIN and END of a CREATE TRIGGER ** statement. ** ** LIMITATIONS: ** ** {U10512} The input to sqlite3_complete() must be a zero-terminated ** UTF-8 string. ** ** {U10513} The input to sqlite3_complete16() must be a zero-terminated ** UTF-16 string in native byte order. */ int sqlite3_complete(const char *sql); int sqlite3_complete16(const void *sql); /* ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310} ** ** This routine identifies a callback function that might be ** invoked whenever an attempt is made to open a database table ** that another thread or process has locked. ** If the busy callback is NULL, then [SQLITE_BUSY] ** or [SQLITE_IOERR_BLOCKED] ** is returned immediately upon encountering the lock. ** If the busy callback is not NULL, then the ** callback will be invoked with two arguments. The ** first argument to the handler is a copy of the void* pointer which ** is the third argument to this routine. The second argument to ** the handler is the number of times that the busy handler has ** been invoked for this locking event. If the ** busy callback returns 0, then no additional attempts are made to ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. ** If the callback returns non-zero, then another attempt ** is made to open the database for reading and the cycle repeats. ** ** The presence of a busy handler does not guarantee that ** it will be invoked when there is lock contention. ** If SQLite determines that invoking the busy handler could result in ** a deadlock, it will go ahead and return [SQLITE_BUSY] or ** [SQLITE_IOERR_BLOCKED] instead of invoking the ** busy handler. ** Consider a scenario where one process is holding a read lock that ** it is trying to promote to a reserved lock and ** a second process is holding a reserved lock that it is trying ** to promote to an exclusive lock. The first process cannot proceed ** because it is blocked by the second and the second process cannot ** proceed because it is blocked by the first. If both processes ** invoke the busy handlers, neither will make any progress. Therefore, ................................................................................ ** to promote this lock to EXCLUSIVE so that it can spill cache ** pages into the database file without harm to concurrent ** readers. If it is unable to promote the lock, then the in-memory ** cache will be left in an inconsistent state and so the error ** code is promoted from the relatively benign [SQLITE_BUSY] to ** the more severe [SQLITE_IOERR_BLOCKED]. This error code promotion ** forces an automatic rollback of the changes. See the ** <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError"> ** CorruptionFollowingBusyError</a> wiki page for a discussion of why ** this is important. ** ** There can only be a single busy handler defined for each database ** connection. Setting a new busy handler clears any previous one. ** Note that calling [sqlite3_busy_timeout()] will also set or clear ** the busy handler. ** ** INVARIANTS: ** ** {F12311} The [sqlite3_busy_handler()] function replaces the busy handler ** callback in the database connection identified by the 1st ** parameter with a new busy handler identified by the 2nd and 3rd ** parameters. ** ** {F12312} The default busy handler for new database connections is NULL. ** ** {F12314} When two or more database connection share a common cache, ** the busy handler for the database connection currently using ** the cache is invoked when the cache encounters a lock. ** ** {F12316} If a busy handler callback returns zero, then the SQLite ** interface that provoked the locking event will return ** [SQLITE_BUSY]. ** ** {F12318} SQLite will invokes the busy handler with two argument which ** are a copy of the pointer supplied by the 3rd parameter to ** [sqlite3_busy_handler()] and a count of the number of prior ** invocations of the busy handler for the same locking event. ** ** LIMITATIONS: ** ** {U12319} A busy handler should not call close the database connection ** or prepared statement that invoked the busy handler. */ int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); /* ** CAPI3REF: Set A Busy Timeout {F12340} ** ** This routine sets a [sqlite3_busy_handler | busy handler] ** that sleeps for a while when a ** table is locked. The handler will sleep multiple times until ** at least "ms" milliseconds of sleeping have been done. {F12343} After ** "ms" milliseconds of sleeping, the handler returns 0 which ** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. ** ** Calling this routine with an argument less than or equal to zero ** turns off all busy handlers. ** ** There can only be a single busy handler for a particular database ** connection. If another busy handler was defined ** (using [sqlite3_busy_handler()]) prior to calling ** this routine, that other busy handler is cleared. ** ** INVARIANTS: ** ** {F12341} The [sqlite3_busy_timeout()] function overrides any prior ** [sqlite3_busy_timeout()] or [sqlite3_busy_handler()] setting ** on the same database connection. ** ** {F12343} If the 2nd parameter to [sqlite3_busy_timeout()] is less than ** or equal to zero, then the busy handler is cleared so that ** all subsequent locking events immediately return [SQLITE_BUSY]. ** ** {F12344} If the 2nd parameter to [sqlite3_busy_timeout()] is a positive ** number N, then a busy handler is set that repeatedly calls ** the xSleep() method in the VFS interface until either the ** lock clears or until the cumulative sleep time reported back ** by xSleep() exceeds N milliseconds. */ int sqlite3_busy_timeout(sqlite3*, int ms); /* ** CAPI3REF: Convenience Routines For Running Queries {F12370} ** ** Definition: A <b>result table</b> is memory data structure created by the ................................................................................ ** complete query results from one or more queries. ** ** The table conceptually has a number of rows and columns. But ** these numbers are not part of the result table itself. These ** numbers are obtained separately. Let N be the number of rows ** and M be the number of columns. ** ** A result table is an array of pointers to zero-terminated ** UTF-8 strings. There are (N+1)*M elements in the array. ** The first M pointers point to zero-terminated strings that ** contain the names of the columns. ** The remaining entries all point to query results. NULL ** values are give a NULL pointer. All other values are in ** their UTF-8 zero-terminated string representation as returned by ** [sqlite3_column_text()]. ** ** A result table might consists of one or more memory allocations. ** It is not safe to pass a result table directly to [sqlite3_free()]. ** A result table should be deallocated using [sqlite3_free_table()]. ** ** As an example of the result table format, suppose a query result ** is as follows: ** ** <blockquote><pre> ................................................................................ ** </pre></blockquote> ** ** The sqlite3_get_table() function evaluates one or more ** semicolon-separated SQL statements in the zero-terminated UTF-8 ** string of its 2nd parameter. It returns a result table to the ** pointer given in its 3rd parameter. ** ** After the calling function has finished using the result, it should ** pass the pointer to the result table to sqlite3_free_table() in order to ** release the memory that was malloc-ed. Because of the way the ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling ** function must not try to call [sqlite3_free()] directly. Only ** [sqlite3_free_table()] is able to release the memory properly and safely. ** ** The sqlite3_get_table() interface is implemented as a wrapper around ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access ** to any internal data structures of SQLite. It uses only the public ** interface defined here. As a consequence, errors that occur in the ** wrapper layer outside of the internal [sqlite3_exec()] call are not ** reflected in subsequent calls to [sqlite3_errcode()] or ** [sqlite3_errmsg()]. ** ** INVARIANTS: ** ** {F12371} If a [sqlite3_get_table()] fails a memory allocation, then ** it frees the result table under construction, aborts the ** query in process, skips any subsequent queries, sets the ** *resultp output pointer to NULL and returns [SQLITE_NOMEM]. ** ** {F12373} If the ncolumn parameter to [sqlite3_get_table()] is not NULL ** then [sqlite3_get_table()] write the number of columns in the ** result set of the query into *ncolumn if the query is ** successful (if the function returns SQLITE_OK). ** ** {F12374} If the nrow parameter to [sqlite3_get_table()] is not NULL ** then [sqlite3_get_table()] write the number of rows in the ** result set of the query into *nrow if the query is ** successful (if the function returns SQLITE_OK). ** ** {F12376} The [sqlite3_get_table()] function sets its *ncolumn value ** to the number of columns in the result set of the query in the ** sql parameter, or to zero if the query in sql has an empty ** result set. */ int sqlite3_get_table( sqlite3*, /* An open database */ const char *sql, /* SQL to be evaluated */ char ***pResult, /* Results of the query */ int *nrow, /* Number of result rows written here */ int *ncolumn, /* Number of result columns written here */ char **errmsg /* Error msg written here */ ); void sqlite3_free_table(char **result); /* ** CAPI3REF: Formatted String Printing Functions {F17400} ** ** These routines are workalikes of the "printf()" family of functions ** from the standard C library. ** ** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their ** results into memory obtained from [sqlite3_malloc()]. ** The strings returned by these two routines should be ** released by [sqlite3_free()]. Both routines return a ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough ** memory to hold the resulting string. ** ** In sqlite3_snprintf() routine is similar to "snprintf()" from ** the standard C library. The result is written into the ** buffer supplied as the second parameter whose size is given by ** the first parameter. Note that the order of the ................................................................................ ** guarantees that the buffer is always zero-terminated. The first ** parameter "n" is the total size of the buffer, including space for ** the zero terminator. So the longest string that can be completely ** written will be n-1 characters. ** ** These routines all implement some additional formatting ** options that are useful for constructing SQL statements. ** All of the usual printf formatting options apply. In addition, there ** is are "%q", "%Q", and "%z" options. ** ** The %q option works like %s in that it substitutes a null-terminated ** string from the argument list. But %q also doubles every '\'' character. ** %q is designed for use inside a string literal. By doubling each '\'' ** character it escapes that character and allows it to be inserted into ** the string. ** ** For example, so some string variable contains text as follows: ** ** <blockquote><pre> ** char *zText = "It's a happy day!"; ** </pre></blockquote> ** ** One can use this text in an SQL statement as follows: ** ................................................................................ ** This is correct. Had we used %s instead of %q, the generated SQL ** would have looked like this: ** ** <blockquote><pre> ** INSERT INTO table1 VALUES('It's a happy day!'); ** </pre></blockquote> ** ** This second example is an SQL syntax error. As a general rule you ** should always use %q instead of %s when inserting text into a string ** literal. ** ** The %Q option works like %q except it also adds single quotes around ** the outside of the total string. Or if the parameter in the argument ** list is a NULL pointer, %Q substitutes the text "NULL" (without single ** quotes) in place of the %Q option. {END} So, for example, one could say: ** ** <blockquote><pre> ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText); ** sqlite3_exec(db, zSQL, 0, 0, 0); ** sqlite3_free(zSQL); ** </pre></blockquote> ** ................................................................................ ** memory obtained from [sqlite3_malloc()] or NULL pointers if ** a call to [sqlite3_malloc()] fails. ** ** {F17406} The [sqlite3_snprintf()] interface writes a zero-terminated ** UTF-8 string into the buffer pointed to by the second parameter ** provided that the first parameter is greater than zero. ** ** {F17407} The [sqlite3_snprintf()] interface does not writes slots of ** its output buffer (the second parameter) outside the range ** of 0 through N-1 (where N is the first parameter) ** regardless of the length of the string ** requested by the format specification. ** */ char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); char *sqlite3_snprintf(int,char*,const char*, ...); /* ** CAPI3REF: Memory Allocation Subsystem {F17300} ** ** The SQLite core uses these three routines for all of its own ** internal memory allocation needs. "Core" in the previous sentence ** does not include operating-system specific VFS implementation. The ** windows VFS uses native malloc and free for some operations. ** ** The sqlite3_malloc() routine returns a pointer to a block ** of memory at least N bytes in length, where N is the parameter. ** If sqlite3_malloc() is unable to obtain sufficient free ** memory, it returns a NULL pointer. If the parameter N to ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns ** a NULL pointer. ................................................................................ ** second parameter. The memory allocation to be resized is the first ** parameter. If the first parameter to sqlite3_realloc() ** is a NULL pointer then its behavior is identical to calling ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). ** If the second parameter to sqlite3_realloc() is zero or ** negative then the behavior is exactly the same as calling ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). ** Sqlite3_realloc() returns a pointer to a memory allocation ** of at least N bytes in size or NULL if sufficient memory is unavailable. ** If M is the size of the prior allocation, then min(N,M) bytes ** of the prior allocation are copied into the beginning of buffer returned ** by sqlite3_realloc() and the prior allocation is freed. ** If sqlite3_realloc() returns NULL, then the prior allocation ** is not freed. ** ** The memory returned by sqlite3_malloc() and sqlite3_realloc() ** is always aligned to at least an 8 byte boundary. {END} ** ** The default implementation ** of the memory allocation subsystem uses the malloc(), realloc() ** and free() provided by the standard C library. {F17382} However, if ** SQLite is compiled with the following C preprocessor macro ** ** <blockquote> SQLITE_MEMORY_SIZE=<i>NNN</i> </blockquote> ** ** where <i>NNN</i> is an integer, then SQLite create a static ** array of at least <i>NNN</i> bytes in size and use that array ** for all of its dynamic memory allocation needs. {END} Additional ** memory allocator options may be added in future releases. ** ** In SQLite version 3.5.0 and 3.5.1, it was possible to define ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in ** implementation of these routines to be omitted. That capability ** is no longer provided. Only built-in memory allocators can be ** used. ** ** The windows OS interface layer calls ** the system malloc() and free() directly when converting ** filenames between the UTF-8 encoding used by SQLite ** and whatever filename encoding is used by the particular windows ** installation. Memory allocation errors are detected, but ** they are reported back as [SQLITE_CANTOPEN] or ** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. ** ** INVARIANTS: ** ** {F17303} The [sqlite3_malloc(N)] interface returns either a pointer to ** newly checked-out block of at least N bytes of memory ** that is 8-byte aligned, ** or it returns NULL if it is unable to fulfill the request. ** ** {F17304} The [sqlite3_malloc(N)] interface returns a NULL pointer if ** N is less than or equal to zero. ** ** {F17305} The [sqlite3_free(P)] interface releases memory previously ** returned from [sqlite3_malloc()] or [sqlite3_realloc()], ** making it available for reuse. ................................................................................ ** deallocation needs. ** ** {F17318} The [sqlite3_realloc(P,N)] interface returns either a pointer ** to a block of checked-out memory of at least N bytes in size ** that is 8-byte aligned, or a NULL pointer. ** ** {F17321} When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first ** copies the first K bytes of content from P into the newly allocated ** where K is the lessor of N and the size of the buffer P. ** ** {F17322} When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first ** releases the buffer P. ** ** {F17323} When [sqlite3_realloc(P,N)] returns NULL, the buffer P is ** not modified or released. ** ** LIMITATIONS: ** ** {U17350} The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] ** must be either NULL or else a pointer obtained from a prior ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that has ** not been released. ** ** {U17351} The application must not read or write any part of ** a block of memory after it has been released using ** [sqlite3_free()] or [sqlite3_realloc()]. ** */ void *sqlite3_malloc(int); void *sqlite3_realloc(void*, int); void sqlite3_free(void*); /* ** CAPI3REF: Memory Allocator Statistics {F17370} ** ** SQLite provides these two interfaces for reporting on the status ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] ** the memory allocation subsystem included within the SQLite. ** ** INVARIANTS: ** ** {F17371} The [sqlite3_memory_used()] routine returns the ** number of bytes of memory currently outstanding ** (malloced but not freed). ** ** {F17373} The [sqlite3_memory_highwater()] routine returns the maximum ** value of [sqlite3_memory_used()] ** since the highwater mark was last reset. ** ** {F17374} The values returned by [sqlite3_memory_used()] and ** [sqlite3_memory_highwater()] include any overhead ** added by SQLite in its implementation of [sqlite3_malloc()], ** but not overhead added by the any underlying system library ** routines that [sqlite3_malloc()] may call. ** ** {F17375} The memory highwater mark is reset to the current value of ** [sqlite3_memory_used()] if and only if the parameter to ** [sqlite3_memory_highwater()] is true. The value returned ** by [sqlite3_memory_highwater(1)] is the highwater mark ** prior to the reset. */ sqlite3_int64 sqlite3_memory_used(void); sqlite3_int64 sqlite3_memory_highwater(int resetFlag); /* ** CAPI3REF: Pseudo-Random Number Generator {F17390} ** ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to ** select random ROWIDs when inserting new records into a table that ** already uses the largest possible ROWID. The PRNG is also used for ** the build-in random() and randomblob() SQL functions. This interface allows ** appliations to access the same PRNG for other purposes. ** ** A call to this routine stores N bytes of randomness into buffer P. ** ** The first time this routine is invoked (either internally or by ** the application) the PRNG is seeded using randomness obtained ** from the xRandomness method of the default [sqlite3_vfs] object. ** On all subsequent invocations, the pseudo-randomness is generated ................................................................................ ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. At various ** points during the compilation process, as logic is being created ** to perform various actions, the authorizer callback is invoked to ** see if those actions are allowed. The authorizer callback should ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the ** specific action but allow the SQL statement to continue to be ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be ** rejected with an error. If the authorizer callback returns ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] ** then [sqlite3_prepare_v2()] or equivalent call that triggered ** the authorizer will fail with an error message. ** ** When the callback returns [SQLITE_OK], that means the operation ** requested is ok. When the callback returns [SQLITE_DENY], the ** [sqlite3_prepare_v2()] or equivalent call that triggered the ** authorizer will fail with an error message explaining that ** access is denied. If the authorizer code is [SQLITE_READ] ................................................................................ ** and the callback returns [SQLITE_IGNORE] then the ** [prepared statement] statement is constructed to substitute ** a NULL value in place of the table column that would have ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] ** return can be used to deny an untrusted user access to individual ** columns of a table. ** ** The first parameter to the authorizer callback is a copy of ** the third parameter to the sqlite3_set_authorizer() interface. ** The second parameter to the callback is an integer ** [SQLITE_COPY | action code] that specifies the particular action ** to be authorized. The third through sixth ** parameters to the callback are zero-terminated strings that contain ** additional details about the action to be authorized. ** ** An authorizer is used when [sqlite3_prepare | preparing] ** SQL statements from an untrusted ** source, to ensure that the SQL statements do not try to access data ** that they are not allowed to see, or that they do not try to ** execute malicious statements that damage the database. For ** example, an application may allow a user to enter arbitrary ** SQL queries for evaluation by a database. But the application does ** not want the user to be able to make arbitrary changes to the ** database. An authorizer could then be put in place while the ** user-entered SQL is being [sqlite3_prepare | prepared] that ** disallows everything except [SELECT] statements. ** ................................................................................ ** in addition to using an authorizer. ** ** Only a single authorizer can be in place on a database connection ** at a time. Each call to sqlite3_set_authorizer overrides the ** previous call. Disable the authorizer by installing a NULL callback. ** The authorizer is disabled by default. ** ** Note that the authorizer callback is invoked only during ** [sqlite3_prepare()] or its variants. Authorization is not ** performed during statement evaluation in [sqlite3_step()]. ** ** INVARIANTS: ** ** {F12501} The [sqlite3_set_authorizer(D,...)] interface registers a ** authorizer callback with database connection D. ** ** {F12502} The authorizer callback is invoked as SQL statements are ** being compiled ** ** {F12503} If the authorizer callback returns any value other than ** [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] then ** the [sqlite3_prepare_v2()] or equivalent call that caused ** the authorizer callback to run shall fail with an ** [SQLITE_ERROR] error code and an appropriate error message. ** ** {F12504} When the authorizer callback returns [SQLITE_OK], the operation ** described is coded normally. ** ** {F12505} When the authorizer callback returns [SQLITE_DENY], the ** [sqlite3_prepare_v2()] or equivalent call that caused the ** authorizer callback to run shall fail ** with an [SQLITE_ERROR] error code and an error message ** explaining that access is denied. ** ** {F12506} If the authorizer code (the 2nd parameter to the authorizer ** callback) is [SQLITE_READ] and the authorizer callback returns ** [SQLITE_IGNORE] then the prepared statement is constructed to ** insert a NULL value in place of the table column that would have ** been read if [SQLITE_OK] had been returned. ** ** {F12507} If the authorizer code (the 2nd parameter to the authorizer ** callback) is anything other than [SQLITE_READ], then ** a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. ** ** {F12510} The first parameter to the authorizer callback is a copy of ** the third parameter to the [sqlite3_set_authorizer()] interface. ** ** {F12511} The second parameter to the callback is an integer ** [SQLITE_COPY | action code] that specifies the particular action ** to be authorized. ** ** {F12512} The third through sixth parameters to the callback are ** zero-terminated strings that contain ** additional details about the action to be authorized. ** ** {F12520} Each call to [sqlite3_set_authorizer()] overrides the ** any previously installed authorizer. ** ** {F12521} A NULL authorizer means that no authorization ** callback is invoked. ** ** {F12522} The default authorizer is NULL. */ ................................................................................ #define SQLITE_DENY 1 /* Abort the SQL statement with an error */ #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ /* ** CAPI3REF: Authorizer Action Codes {F12550} ** ** The [sqlite3_set_authorizer()] interface registers a callback function ** that is invoked to authorizer certain SQL statement actions. The ** second parameter to the callback is an integer code that specifies ** what action is being authorized. These are the integer action codes that ** the authorizer callback may be passed. ** ** These action code values signify what kind of operation is to be ** authorized. The 3rd and 4th parameters to the authorization ** callback function will be parameters or NULL depending on which of these ** codes is used as the second parameter. The 5th parameter to the ** authorizer callback is the name of the database ("main", "temp", ** etc.) if applicable. The 6th parameter to the authorizer callback ** is the name of the inner-most trigger or view that is responsible for ** the access attempt or NULL if this access attempt is directly from ** top-level SQL code. ** ** INVARIANTS: ** ** {F12551} The second parameter to an ** [sqlite3_set_authorizer | authorizer callback is always an integer ** [SQLITE_COPY | authorizer code] that specifies what action ** is being authorized. ** ** {F12552} The 3rd and 4th parameters to the ** [sqlite3_set_authorizer | authorization callback function] ** will be parameters or NULL depending on which ** [SQLITE_COPY | authorizer code] is used as the second parameter. ** ** {F12553} The 5th parameter to the ** [sqlite3_set_authorizer | authorizer callback] is the name ** of the database (example: "main", "temp", etc.) if applicable. ** ** {F12554} The 6th parameter to the ** [sqlite3_set_authorizer | authorizer callback] is the name ** of the inner-most trigger or view that is responsible for ** the access attempt or NULL if this access attempt is directly from ** top-level SQL code. */ /******************************************* 3rd ************ 4th ***********/ #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ ................................................................................ ** These routines register callback functions that can be used for ** tracing and profiling the execution of SQL statements. ** ** The callback function registered by sqlite3_trace() is invoked at ** various times when an SQL statement is being run by [sqlite3_step()]. ** The callback returns a UTF-8 rendering of the SQL statement text ** as the statement first begins executing. Additional callbacks occur ** as each triggersubprogram is entered. The callbacks for triggers ** contain a UTF-8 SQL comment that identifies the trigger. ** ** The callback function registered by sqlite3_profile() is invoked ** as each SQL statement finishes. The profile callback contains ** the original statement text and an estimate of wall-clock time ** of how long that statement took to run. ** ** The sqlite3_profile() API is currently considered experimental and ** is subject to change or removal in a future release. ** ** The trigger reporting feature of the trace callback is considered ** experimental and is subject to change or removal in future releases. ** Future versions of SQLite might also add new trace callback ** invocations. ** ** INVARIANTS: ** ** {F12281} The callback function registered by [sqlite3_trace()] is ** whenever an SQL statement first begins to execute and ** whenever a trigger subprogram first begins to run. ................................................................................ ** ** {F12283} A NULL trace callback disables tracing. ** ** {F12284} The first argument to the trace callback is a copy of ** the pointer which was the 3rd argument to [sqlite3_trace()]. ** ** {F12285} The second argument to the trace callback is a ** zero-terminated UTF8 string containing the original text ** of the SQL statement as it was passed into [sqlite3_prepare_v2()] ** or the equivalent, or an SQL comment indicating the beginning ** of a trigger subprogram. ** ** {F12287} The callback function registered by [sqlite3_profile()] is invoked ** as each SQL statement finishes. ** ................................................................................ ** the 3rd parameter to [sqlite3_profile()]. ** ** {F12289} The second parameter to the profile callback is a ** zero-terminated UTF-8 string that contains the complete text of ** the SQL statement as it was processed by [sqlite3_prepare_v2()] ** or the equivalent. ** ** {F12290} The third parameter to the profile callback is an estimate ** of the number of nanoseconds of wall-clock time required to ** run the SQL statement from start to finish. */ void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); void *sqlite3_profile(sqlite3*, void(*xProfile)(void*,const char*,sqlite3_uint64), void*); /* ** CAPI3REF: Query Progress Callbacks {F12910} ** ** This routine configures a callback function - the ** progress callback - that is invoked periodically during long ** running calls to [sqlite3_exec()], [sqlite3_step()] and ** [sqlite3_get_table()]. An example use for this ** interface is to keep a GUI updated during a large query. ** ** If the progress callback returns non-zero, the opertion is ** interrupted. This feature can be used to implement a ** "Cancel" button on a GUI dialog box. ** ** INVARIANTS: ** ** {F12911} The callback function registered by [sqlite3_progress_handler()] ** is invoked periodically during long running calls to ** [sqlite3_step()]. ** ** {F12912} The progress callback is invoked once for every N virtual ** machine opcodes, where N is the second argument to ** the [sqlite3_progress_handler()] call that registered ** the callback. <todo>What if N is less than 1?</todo> ** ** {F12913} The progress callback itself is identified by the third ** argument to [sqlite3_progress_handler()]. ** ** {F12914} The fourth argument [sqlite3_progress_handler()] is a *** void pointer passed to the progress callback ** function each time it is invoked. ** ** {F12915} If a call to [sqlite3_step()] results in fewer than ** N opcodes being executed, ** then the progress callback is never invoked. {END} ** ** {F12916} Every call to [sqlite3_progress_handler()] ** overwrites any previously registere progress handler. ** ** {F12917} If the progress handler callback is NULL then no progress ** handler is invoked. ** ** {F12918} If the progress callback returns a result other than 0, then ** the behavior is a if [sqlite3_interrupt()] had been called. */ void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); /* ** CAPI3REF: Opening A New Database Connection {F12700} ** ** These routines open an SQLite database file whose name ** is given by the filename argument. ** The filename argument is interpreted as UTF-8 ** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 ** in the native byte order for [sqlite3_open16()]. ** An [sqlite3*] handle is usually returned in *ppDb, even ** if an error occurs. The only exception is if SQLite is unable ** to allocate memory to hold the [sqlite3] object, a NULL will ** be written into *ppDb instead of a pointer to the [sqlite3] object. ** If the database is opened (and/or created) ** successfully, then [SQLITE_OK] is returned. Otherwise an ** error code is returned. The ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain ** an English language description of the error. ** ** The default encoding for the database will be UTF-8 if ** [sqlite3_open()] or [sqlite3_open_v2()] is called and ** UTF-16 in the native byte order if [sqlite3_open16()] is used. ** ** Whether or not an error occurs when it is opened, resources ** associated with the [sqlite3*] handle should be released by passing it ** to [sqlite3_close()] when it is no longer required. ** ** The [sqlite3_open_v2()] interface works like [sqlite3_open()] ** except that it acccepts two additional parameters for additional control ** over the new database connection. The flags parameter can be ** one of: ** ** <ol> ** <li> [SQLITE_OPEN_READONLY] ** <li> [SQLITE_OPEN_READWRITE] ** <li> [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE] ** </ol> ** ** The first value opens the database read-only. ** If the database does not previously exist, an error is returned. ** The second option opens ** the database for reading and writing if possible, or reading only if ** if the file is write protected. In either case the database ** must already exist or an error is returned. The third option ** opens the database for reading and writing and creates it if it does ** not already exist. ** The third options is behavior that is always used for [sqlite3_open()] ** and [sqlite3_open16()]. ** ** If the 3rd parameter to [sqlite3_open_v2()] is not one of the ** combinations shown above then the behavior is undefined. ** ** If the filename is ":memory:", then an private ** in-memory database is created for the connection. This in-memory ** database will vanish when the database connection is closed. Future ** version of SQLite might make use of additional special filenames ** that begin with the ":" character. It is recommended that ** when a database filename really does begin with ** ":" that you prefix the filename with a pathname like "./" to ** avoid ambiguity. ** ** If the filename is an empty string, then a private temporary ** on-disk database will be created. This private database will be ** automatically deleted as soon as the database connection is closed. ** ** The fourth parameter to sqlite3_open_v2() is the name of the ** [sqlite3_vfs] object that defines the operating system ** interface that the new database connection should use. If the ** fourth parameter is a NULL pointer then the default [sqlite3_vfs] ** object is used. ** ** <b>Note to windows users:</b> The encoding used for the filename argument ** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever ** codepage is currently defined. Filenames containing international ** characters must be converted to UTF-8 prior to passing them into ** [sqlite3_open()] or [sqlite3_open_v2()]. ** ** INVARIANTS: ** ** {F12701} The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces create a new ** [database connection] associated with ** the database file given in their first parameter. ** ** {F12702} The filename argument is interpreted as UTF-8 ** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 ** in the native byte order for [sqlite3_open16()]. ** ** {F12703} A successful invocation of [sqlite3_open()], [sqlite3_open16()], ** or [sqlite3_open_v2()] writes a pointer to a new ** [database connection] into *ppDb. ** ** {F12704} The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces return [SQLITE_OK] upon success, ** or an appropriate [error code] on failure. ** ................................................................................ ** {F12717} If the filename argument to [sqlite3_open()], [sqlite3_open16()], ** or [sqlite3_open_v2()] is ":memory:", then an private, ** ephemeral, in-memory database is created for the connection. ** <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required ** in sqlite3_open_v2()?</todo> ** ** {F12719} If the filename is NULL or an empty string, then a private, ** ephermeral on-disk database will be created. ** <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required ** in sqlite3_open_v2()?</todo> ** ** {F12721} The [database connection] created by ** [sqlite3_open_v2(F,D,G,V)] will use the ** [sqlite3_vfs] object identified by the V parameter, or ** the default [sqlite3_vfs] object is V is a NULL pointer. */ int sqlite3_open( const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb /* OUT: SQLite db handle */ ); int sqlite3_open16( const void *filename, /* Database filename (UTF-16) */ ................................................................................ int flags, /* Flags */ const char *zVfs /* Name of VFS module to use */ ); /* ** CAPI3REF: Error Codes And Messages {F12800} ** ** The sqlite3_errcode() interface returns the numeric ** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code] ** for the most recent failed sqlite3_* API call associated ** with [sqlite3] handle 'db'. If a prior API call failed but the ** most recent API call succeeded, the return value from sqlite3_errcode() ** is undefined. ** ** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language ** text that describes the error, as either UTF8 or UTF16 respectively. ** Memory to hold the error message string is managed internally. ** The application does not need to worry with freeing the result. ** However, the error string might be overwritten or deallocated by ** subsequent calls to other SQLite interface functions. ** ** INVARIANTS: ** ** {F12801} The [sqlite3_errcode(D)] interface returns the numeric ** [SQLITE_OK | result code] or ** [SQLITE_IOERR_READ | extended result code] ** for the most recently failed interface call associated ** with [database connection] D. ** ** {F12803} The [sqlite3_errmsg(D)] and [sqlite3_errmsg16(D)] ** interfaces return English-language text that describes ** the error in the mostly recently failed interface call, ** encoded as either UTF8 or UTF16 respectively. ** ** {F12807} The strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()] ** are valid until the next SQLite interface call. ** ** {F12808} Calls to API routines that do not return an error code ** (example: [sqlite3_data_count()]) do not ** change the error code or message returned by ................................................................................ const char *sqlite3_errmsg(sqlite3*); const void *sqlite3_errmsg16(sqlite3*); /* ** CAPI3REF: SQL Statement Object {F13000} ** KEYWORDS: {prepared statement} {prepared statements} ** ** An instance of this object represent single SQL statements. This ** object is variously known as a "prepared statement" or a ** "compiled SQL statement" or simply as a "statement". ** ** The life of a statement object goes something like this: ** ** <ol> ** <li> Create the object using [sqlite3_prepare_v2()] or a related ** function. ** <li> Bind values to host parameters using ** [sqlite3_bind_blob | sqlite3_bind_* interfaces]. ** <li> Run the SQL by calling [sqlite3_step()] one or more times. ** <li> Reset the statement using [sqlite3_reset()] then go back ** to step 2. Do this zero or more times. ** <li> Destroy the object using [sqlite3_finalize()]. ** </ol> ** ** Refer to documentation on individual methods above for additional ................................................................................ ** [database connection] whose limit is to be set or queried. The ** second parameter is one of the [limit categories] that define a ** class of constructs to be size limited. The third parameter is the ** new limit for that construct. The function returns the old limit. ** ** If the new limit is a negative number, the limit is unchanged. ** For the limit category of SQLITE_LIMIT_XYZ there is a hard upper ** bound set by a compile-time C-preprocess macro named SQLITE_MAX_XYZ. ** (The "_LIMIT_" in the name is changed to "_MAX_".) ** Attempts to increase a limit above its hard upper bound are ** silently truncated to the hard upper limit. ** ** Run time limits are intended for use in applications that manage ** both their own internal database and also databases that are controlled ** by untrusted external sources. An example application might be a ** webbrowser that has its own databases for storing history and ** separate databases controlled by javascript applications downloaded ** off the internet. The internal databases can be given the ** large, default limits. Databases managed by external sources can ** be given much smaller limits designed to prevent a denial of service ** attach. Developers might also want to use the [sqlite3_set_authorizer()] ** interface to further control untrusted SQL. The size of the database ** created by an untrusted script can be contained using the ** [max_page_count] [PRAGMA]. ** ** This interface is currently considered experimental and is subject ** to change or removal without prior notice. ** ** INVARIANTS: ** ** {F12762} A successful call to [sqlite3_limit(D,C,V)] where V is ** positive changes the ** limit on the size of construct C in [database connection] D ** to the lessor of V and the hard upper bound on the size ** of C that is set at compile-time. ** ** {F12766} A successful call to [sqlite3_limit(D,C,V)] where V is negative ** leaves the state of [database connection] D unchanged. ** ** {F12769} A successful call to [sqlite3_limit(D,C,V)] returns the ** value of the limit on the size of construct C in ** in [database connection] D as it was prior to the call. */ int sqlite3_limit(sqlite3*, int id, int newVal); /* ** CAPI3REF: Run-Time Limit Categories {F12790} ** KEYWORDS: {limit category} {limit categories} ** ** These constants define various aspects of a [database connection] ** that can be limited in size by calls to [sqlite3_limit()]. ** The meanings of the various limits are as follows: ** ** <dl> ** <dt>SQLITE_LIMIT_LENGTH</dt> ** <dd>The maximum size of any ** string or blob or table row.<dd> ** ** <dt>SQLITE_LIMIT_SQL_LENGTH</dt> ** <dd>The maximum length of an SQL statement.</dd> ** ** <dt>SQLITE_LIMIT_COLUMN</dt> ** <dd>The maximum number of columns in a table definition or in the ** result set of a SELECT or the maximum number of columns in an index ................................................................................ #define SQLITE_LIMIT_FUNCTION_ARG 6 #define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 /* ** CAPI3REF: Compiling An SQL Statement {F13010} ** ** To execute an SQL query, it must first be compiled into a byte-code ** program using one of these routines. ** ** The first argument "db" is an [database connection] ** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()] ** or [sqlite3_open16()]. ** The second argument "zSql" is the statement to be compiled, encoded ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() ** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2() ** use UTF-16. {END} ** ** If the nByte argument is less ** than zero, then zSql is read up to the first zero terminator. ** If nByte is non-negative, then it is the maximum number of ** bytes read from zSql. When nByte is non-negative, the ** zSql string ends at either the first '\000' or '\u0000' character or ** the nByte-th byte, whichever comes first. If the caller knows ** that the supplied string is nul-terminated, then there is a small ** performance advantage to be had by passing an nByte parameter that ** is equal to the number of bytes in the input string <i>including</i> ** the nul-terminator bytes.{END} ** ** *pzTail is made to point to the first byte past the end of the ** first SQL statement in zSql. These routines only compiles the first ** statement in zSql, so *pzTail is left pointing to what remains ** uncompiled. ** ** *ppStmt is left pointing to a compiled [prepared statement] that can be ** executed using [sqlite3_step()]. Or if there is an error, *ppStmt is ** set to NULL. If the input text contains no SQL (if the input ** is and empty string or a comment) then *ppStmt is set to NULL. ** {U13018} The calling procedure is responsible for deleting the ** compiled SQL statement ** using [sqlite3_finalize()] after it has finished with it. ** ** On success, [SQLITE_OK] is returned. Otherwise an ** [error code] is returned. ** ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are ** recommended for all new programs. The two older interfaces are retained ** for backwards compatibility, but their use is discouraged. ** In the "v2" interfaces, the prepared statement ** that is returned (the [sqlite3_stmt] object) contains a copy of the ** original SQL text. {END} This causes the [sqlite3_step()] interface to ** behave a differently in two ways: ** ** <ol> ** <li> ** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it ** always used to do, [sqlite3_step()] will automatically recompile the SQL ** statement and try to run it again. If the schema has changed in ** a way that makes the statement no longer valid, [sqlite3_step()] will still ** return [SQLITE_SCHEMA]. But unlike the legacy behavior, ** [SQLITE_SCHEMA] is now a fatal error. Calling ** [sqlite3_prepare_v2()] again will not make the ** error go away. Note: use [sqlite3_errmsg()] to find the text ** of the parsing error that results in an [SQLITE_SCHEMA] return. {END} ** </li> ** ** <li> ** When an error occurs, ** [sqlite3_step()] will return one of the detailed ** [error codes] or [extended error codes]. ** The legacy behavior was that [sqlite3_step()] would only return a generic ** [SQLITE_ERROR] result code and you would have to make a second call to ** [sqlite3_reset()] in order to find the underlying cause of the problem. ** With the "v2" prepare interfaces, the underlying reason for the error is ** returned immediately. ** </li> ** </ol> ** ** INVARIANTS: ** ** {F13011} The [sqlite3_prepare(db,zSql,...)] and ** [sqlite3_prepare_v2(db,zSql,...)] interfaces interpret the ................................................................................ ** text in their zSql parameter as UTF-8. ** ** {F13012} The [sqlite3_prepare16(db,zSql,...)] and ** [sqlite3_prepare16_v2(db,zSql,...)] interfaces interpret the ** text in their zSql parameter as UTF-16 in the native byte order. ** ** {F13013} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)] ** and its variants is less than zero, then SQL text is ** read from zSql is read up to the first zero terminator. ** ** {F13014} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)] ** and its variants is non-negative, then at most nBytes bytes ** SQL text is read from zSql. ** ** {F13015} In [sqlite3_prepare_v2(db,zSql,N,P,pzTail)] and its variants ** if the zSql input text contains more than one SQL statement ** and pzTail is not NULL, then *pzTail is made to point to the ** first byte past the end of the first SQL statement in zSql. ** <todo>What does *pzTail point to if there is one statement?</todo> ** ** {F13016} A successful call to [sqlite3_prepare_v2(db,zSql,N,ppStmt,...)] ** or one of its variants writes into *ppStmt a pointer to a new ** [prepared statement] or a pointer to NULL ** if zSql contains nothing other than whitespace or comments. ** ** {F13019} The [sqlite3_prepare_v2()] interface and its variants return ** [SQLITE_OK] or an appropriate [error code] upon failure. ** ** {F13021} Before [sqlite3_prepare(db,zSql,nByte,ppStmt,pzTail)] or its ** variants returns an error (any value other than [SQLITE_OK]) ** it first sets *ppStmt to NULL. */ int sqlite3_prepare( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const char **pzTail /* OUT: Pointer to unused portion of zSql */ ................................................................................ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); /* ** CAPIREF: Retrieving Statement SQL {F13100} ** ** This intereface can be used to retrieve a saved copy of the original ** SQL text used to create a [prepared statement]. ** ** INVARIANTS: ** ** {F13101} If the [prepared statement] passed as ** the an argument to [sqlite3_sql()] was compiled ** compiled using either [sqlite3_prepare_v2()] or ** [sqlite3_prepare16_v2()], ** then [sqlite3_sql()] function returns a pointer to a ** zero-terminated string containing a UTF-8 rendering ** of the original SQL statement. ** ** {F13102} If the [prepared statement] passed as ** the an argument to [sqlite3_sql()] was compiled ** compiled using either [sqlite3_prepare()] or ** [sqlite3_prepare16()], ** then [sqlite3_sql()] function returns a NULL pointer. ** ** {F13103} The string returned by [sqlite3_sql(S)] is valid until the ** [prepared statement] S is deleted using [sqlite3_finalize(S)]. */ const char *sqlite3_sql(sqlite3_stmt *pStmt); /* ** CAPI3REF: Dynamically Typed Value Object {F15000} ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} ** ** SQLite uses the sqlite3_value object to represent all values ** that can be stored in a database table. ** SQLite uses dynamic typing for the values it stores. ** Values stored in sqlite3_value objects can be ** be integers, floating point values, strings, BLOBs, or NULL. ** ** An sqlite3_value object may be either "protected" or "unprotected". ** Some interfaces require a protected sqlite3_value. Other interfaces ** will accept either a protected or an unprotected sqlite3_value. ** Every interface that accepts sqlite3_value arguments specifies ** whether or not it requires a protected sqlite3_value. ** ** The terms "protected" and "unprotected" refer to whether or not ** a mutex is held. A internal mutex is held for a protected ** sqlite3_value object but no mutex is held for an unprotected ** sqlite3_value object. If SQLite is compiled to be single-threaded ** (with SQLITE_THREADSAFE=0 and with [sqlite3_threadsafe()] returning 0) ** then there is no distinction between ** protected and unprotected sqlite3_value objects and they can be ** used interchangable. However, for maximum code portability it ** is recommended that applications make the distinction between ** between protected and unprotected sqlite3_value objects even if ** they are single threaded. ** ** The sqlite3_value objects that are passed as parameters into the ** implementation of application-defined SQL functions are protected. ** The sqlite3_value object returned by ** [sqlite3_column_value()] is unprotected. ** Unprotected sqlite3_value objects may only be used with ** [sqlite3_result_value()] and [sqlite3_bind_value()]. All other ** interfaces that use sqlite3_value require protected sqlite3_value objects. */ typedef struct Mem sqlite3_value; /* ** CAPI3REF: SQL Function Context Object {F16001} ** ** The context in which an SQL function executes is stored in an ** sqlite3_context object. A pointer to an sqlite3_context ** object is always first parameter to application-defined SQL functions. */ typedef struct sqlite3_context sqlite3_context; /* ** CAPI3REF: Binding Values To Prepared Statements {F13500} ** ** In the SQL strings input to [sqlite3_prepare_v2()] and its ** variants, literals may be replace by a parameter in one ** of these forms: ** ** <ul> ** <li> ? ** <li> ?NNN ** <li> :VVV ** <li> @VVV ** <li> $VVV ** </ul> ** ** In the parameter forms shown above NNN is an integer literal, ** VVV alpha-numeric parameter name. ** The values of these parameters (also called "host parameter names" ** or "SQL parameters") ** can be set using the sqlite3_bind_*() routines defined here. ** ** The first argument to the sqlite3_bind_*() routines always ** is a pointer to the [sqlite3_stmt] object returned from ** [sqlite3_prepare_v2()] or its variants. The second ** argument is the index of the parameter to be set. The ** first parameter has an index of 1. When the same named ** parameter is used more than once, second and subsequent ** occurrences have the same index as the first occurrence. ** The index for named parameters can be looked up using the ** [sqlite3_bind_parameter_name()] API if desired. The index ** for "?NNN" parameters is the value of NNN. ** The NNN value must be between 1 and the compile-time ** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999). ** ** The third argument is the value to bind to the parameter. ** ** In those ** routines that have a fourth argument, its value is the number of bytes ** in the parameter. To be clear: the value is the number of <u>bytes</u> ** in the value, not the number of characters. ** If the fourth parameter is negative, the length of the string is ** number of bytes up to the first zero terminator. ** ** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or ** string after SQLite has finished with it. If the fifth argument is ** the special value [SQLITE_STATIC], then SQLite assumes that the ** information is in static, unmanaged space and does not need to be freed. ** If the fifth argument has the value [SQLITE_TRANSIENT], then ** SQLite makes its own private copy of the data immediately, before ** the sqlite3_bind_*() routine returns. ** ** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that ** is filled with zeros. A zeroblob uses a fixed amount of memory ** (just an integer to hold it size) while it is being processed. ** Zeroblobs are intended to serve as place-holders for BLOBs whose ** content is later written using ** [sqlite3_blob_open | increment BLOB I/O] routines. A negative ** value for the zeroblob results in a zero-length BLOB. ** ** The sqlite3_bind_*() routines must be called after ** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and ** before [sqlite3_step()]. ** Bindings are not cleared by the [sqlite3_reset()] routine. ** Unbound parameters are interpreted as NULL. ** ** These routines return [SQLITE_OK] on success or an error code if ** anything goes wrong. [SQLITE_RANGE] is returned if the parameter ** index is out of range. [SQLITE_NOMEM] is returned if malloc fails. ** [SQLITE_MISUSE] might be returned if these routines are called on a ** virtual machine that is the wrong state or which has already been finalized. ** Detection of misuse is unreliable. Applications should not depend ** on SQLITE_MISUSE returns. SQLITE_MISUSE is intended to indicate a ** a logic error in the application. Future versions of SQLite might ** panic rather than return SQLITE_MISUSE. ** ** See also: [sqlite3_bind_parameter_count()], ** [sqlite3_bind_parameter_name()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13506} The [sqlite3_prepare | SQL statement compiler] recognizes ** tokens of the forms "?", "?NNN", "$VVV", ":VVV", and "@VVV" ** as SQL parameters, where NNN is any sequence of one or more ** digits and where VVV is any sequence of one or more ** alphanumeric characters or "::" optionally followed by ** a string containing no spaces and contained within parentheses. ** ** {F13509} The initial value of an SQL parameter is NULL. ** ** {F13512} The index of an "?" SQL parameter is one larger than the ** largest index of SQL parameter to the left, or 1 if ** the "?" is the leftmost SQL parameter. ** ** {F13515} The index of an "?NNN" SQL parameter is the integer NNN. ** ** {F13518} The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is ** the same as the index of leftmost occurances of the same ** parameter, or one more than the largest index over all ** parameters to the left if this is the first occurrance ** of this parameter, or 1 if this is the leftmost parameter. ** ** {F13521} The [sqlite3_prepare | SQL statement compiler] fail with ** an [SQLITE_RANGE] error if the index of an SQL parameter ** is less than 1 or greater than SQLITE_MAX_VARIABLE_NUMBER. ** ** {F13524} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,V,...)] ** associate the value V with all SQL parameters having an ** index of N in the [prepared statement] S. ** ** {F13527} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,...)] ** override prior calls with the same values of S and N. ................................................................................ ** ** {F13530} Bindings established by [sqlite3_bind_text | sqlite3_bind(S,...)] ** persist across calls to [sqlite3_reset(S)]. ** ** {F13533} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds the first L ** bytes of the blob or string pointed to by V, when L ** is non-negative. ** ** {F13536} In calls to [sqlite3_bind_text(S,N,V,L,D)] or ** [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds characters ** from V through the first zero character when L is negative. ** ** {F13539} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ................................................................................ ** constant [SQLITE_STATIC], SQLite assumes that the value V ** is held in static unmanaged space that will not change ** during the lifetime of the binding. ** ** {F13542} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] when D is the special ** constant [SQLITE_TRANSIENT], the routine makes a ** private copy of V value before it returns. ** ** {F13545} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] when D is a pointer to ** a function, SQLite invokes that function to destroy the ** V value after it has finished using the V value. ** ** {F13548} In calls to [sqlite3_bind_zeroblob(S,N,V,L)] the value bound ** is a blob of L bytes, or a zero-length blob if L is negative. ** ** {F13551} In calls to [sqlite3_bind_value(S,N,V)] the V argument may ** be either a [protected sqlite3_value] object or an ** [unprotected sqlite3_value] object. */ int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); int sqlite3_bind_double(sqlite3_stmt*, int, double); ................................................................................ int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); /* ** CAPI3REF: Number Of SQL Parameters {F13600} ** ** This routine can be used to find the number of SQL parameters ** in a prepared statement. SQL parameters are tokens of the ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as ** place-holders for values that are [sqlite3_bind_blob | bound] ** to the parameters at a later time. ** ** This routine actually returns the index of the largest parameter. ** For all forms except ?NNN, this will correspond to the number of ** unique parameters. If parameters of the ?NNN are used, there may ** be gaps in the list. ** ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_name()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13601} The [sqlite3_bind_parameter_count(S)] interface returns ** the largest index of all SQL parameters in the ** [prepared statement] S, or 0 if S ** contains no SQL parameters. */ int sqlite3_bind_parameter_count(sqlite3_stmt*); /* ** CAPI3REF: Name Of A Host Parameter {F13620} ** ** This routine returns a pointer to the name of the n-th ** SQL parameter in a [prepared statement]. ** SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" ** respectively. ** In other words, the initial ":" or "$" or "@" or "?" ** is included as part of the name. ** Parameters of the form "?" without a following integer have no name. ** ** The first host parameter has an index of 1, not 0. ** ** If the value n is out of range or if the n-th parameter is ** nameless, then NULL is returned. The returned string is ** always in the UTF-8 encoding even if the named parameter was ** originally specified as UTF-16 in [sqlite3_prepare16()] or ** [sqlite3_prepare16_v2()]. ** ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13621} The [sqlite3_bind_parameter_name(S,N)] interface returns ** a UTF-8 rendering of the name of the SQL parameter in ** [prepared statement] S having index N, or ** NULL if there is no SQL parameter with index N or if the ** parameter with index N is an anonymous parameter "?". */ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); /* ** CAPI3REF: Index Of A Parameter With A Given Name {F13640} ................................................................................ ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13641} The [sqlite3_bind_parameter_index(S,N)] interface returns ** the index of SQL parameter in [prepared statement] ** S whose name matches the UTF-8 string N, or 0 if there is ** no match. */ int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); /* ** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660} ** ** Contrary to the intuition of many, [sqlite3_reset()] does not ** reset the [sqlite3_bind_blob | bindings] on a ** [prepared statement]. Use this routine to ** reset all host parameters to NULL. ** ** INVARIANTS: ** ** {F13661} The [sqlite3_clear_bindings(S)] interface resets all ** SQL parameter bindings in [prepared statement] S ** back to NULL. */ int sqlite3_clear_bindings(sqlite3_stmt*); /* ** CAPI3REF: Number Of Columns In A Result Set {F13710} ** ** Return the number of columns in the result set returned by the ** [prepared statement]. This routine returns 0 ** if pStmt is an SQL statement that does not return data (for ** example an UPDATE). ** ** INVARIANTS: ** ** {F13711} The [sqlite3_column_count(S)] interface returns the number of ** columns in the result set generated by the ** [prepared statement] S, or 0 if S does not generate ** a result set. */ int sqlite3_column_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Column Names In A Result Set {F13720} ** ** These routines return the name assigned to a particular column ** in the result set of a SELECT statement. The sqlite3_column_name() ** interface returns a pointer to a zero-terminated UTF8 string ** and sqlite3_column_name16() returns a pointer to a zero-terminated ** UTF16 string. The first parameter is the ** [prepared statement] that implements the SELECT statement. ** The second parameter is the column number. The left-most column is ** number 0. ** ** The returned string pointer is valid until either the ** [prepared statement] is destroyed by [sqlite3_finalize()] ** or until the next call sqlite3_column_name() or sqlite3_column_name16() ** on the same column. ** ** If sqlite3_malloc() fails during the processing of either routine ** (for example during a conversion from UTF-8 to UTF-16) then a ** NULL pointer is returned. ** ** The name of a result column is the value of the "AS" clause for ** that column, if there is an AS clause. If there is no AS clause ** then the name of the column is unspecified and may change from ** one release of SQLite to the next. ** ** INVARIANTS: ** ** {F13721} A successful invocation of the [sqlite3_column_name(S,N)] ** interface returns the name ** of the Nth column (where 0 is the left-most column) for the ** result set of [prepared statement] S as a ** zero-terminated UTF-8 string. ** ** {F13723} A successful invocation of the [sqlite3_column_name16(S,N)] ** interface returns the name ** of the Nth column (where 0 is the left-most column) for the ** result set of [prepared statement] S as a ** zero-terminated UTF-16 string in the native byte order. ** ** {F13724} The [sqlite3_column_name()] and [sqlite3_column_name16()] ** interfaces return a NULL pointer if they are unable to ** allocate memory memory to hold there normal return strings. ** ** {F13725} If the N parameter to [sqlite3_column_name(S,N)] or ** [sqlite3_column_name16(S,N)] is out of range, then the ** interfaces returns a NULL pointer. ** ** {F13726} The strings returned by [sqlite3_column_name(S,N)] and ** [sqlite3_column_name16(S,N)] are valid until the next ** call to either routine with the same S and N parameters ** or until [sqlite3_finalize(S)] is called. ** ** {F13727} When a result column of a [SELECT] statement contains ** an AS clause, the name of that column is the indentifier ** to the right of the AS keyword. */ const char *sqlite3_column_name(sqlite3_stmt*, int N); const void *sqlite3_column_name16(sqlite3_stmt*, int N); /* ** CAPI3REF: Source Of Data In A Query Result {F13740} ** ** These routines provide a means to determine what column of what ** table in which database a result of a SELECT statement comes from. ** The name of the database or table or column can be returned as ** either a UTF8 or UTF16 string. The _database_ routines return ** the database name, the _table_ routines return the table name, and ** the origin_ routines return the column name. ** The returned string is valid until ** the [prepared statement] is destroyed using ** [sqlite3_finalize()] or until the same information is requested ** again in a different encoding. ** ** The names returned are the original un-aliased names of the ** database, table, and column. ** ** The first argument to the following calls is a [prepared statement]. ** These functions return information about the Nth column returned by ** the statement, where N is the second function argument. ** ** If the Nth column returned by the statement is an expression ** or subquery and is not a column value, then all of these functions ** return NULL. These routine might also return NULL if a memory ** allocation error occurs. Otherwise, they return the ** name of the attached database, table and column that query result ** column was extracted from. ** ** As with all other SQLite APIs, those postfixed with "16" return ** UTF-16 encoded strings, the other functions return UTF-8. {END} ** ** These APIs are only available if the library was compiled with the ** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. ** ** {U13751} ** If two or more threads call one or more of these routines against the same ** prepared statement and column at the same time then the results are ** undefined. ** ** INVARIANTS: ** ** {F13741} The [sqlite3_column_database_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the database from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13742} The [sqlite3_column_database_name16(S,N)] interface returns either ** the UTF-16 native byte order ** zero-terminated name of the database from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13743} The [sqlite3_column_table_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the table from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13744} The [sqlite3_column_table_name16(S,N)] interface returns either ** the UTF-16 native byte order ** zero-terminated name of the table from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13745} The [sqlite3_column_origin_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the table column from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13746} The [sqlite3_column_origin_name16(S,N)] interface returns either ** the UTF-16 native byte order ** zero-terminated name of the table column from which the ** Nth result column of [prepared statement] S ** is extracted, or NULL if the the Nth column of S is a ** general expression or if unable to allocate memory ** to store the name. ** ** {F13748} The return values from ** [sqlite3_column_database_name|column metadata interfaces] ** are valid ** for the lifetime of the [prepared statement] ** or until the encoding is changed by another metadata ** interface call for the same prepared statement and column. ** ** LIMITATIONS: ** ** {U13751} If two or more threads call one or more ** [sqlite3_column_database_name|column metadata interfaces] ** the same [prepared statement] and result column ** at the same time then the results are undefined. */ const char *sqlite3_column_database_name(sqlite3_stmt*,int); const void *sqlite3_column_database_name16(sqlite3_stmt*,int); const char *sqlite3_column_table_name(sqlite3_stmt*,int); const void *sqlite3_column_table_name16(sqlite3_stmt*,int); const char *sqlite3_column_origin_name(sqlite3_stmt*,int); const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); /* ** CAPI3REF: Declared Datatype Of A Query Result {F13760} ** ** The first parameter is a [prepared statement]. ** If this statement is a SELECT statement and the Nth column of the ** returned result set of that SELECT is a table column (not an ** expression or subquery) then the declared type of the table ** column is returned. If the Nth column of the result set is an ** expression or subquery, then a NULL pointer is returned. ** The returned string is always UTF-8 encoded. {END} ** For example, in the database schema: ** ** CREATE TABLE t1(c1 VARIANT); ** ** And the following statement compiled: ** ** SELECT c1 + 1, c1 FROM t1; ** ** Then this routine would return the string "VARIANT" for the second ** result column (i==1), and a NULL pointer for the first result column ** (i==0). ** ** SQLite uses dynamic run-time typing. So just because a column ** is declared to contain a particular type does not mean that the ** data stored in that column is of the declared type. SQLite is ** strongly typed, but the typing is dynamic not static. Type ** is associated with individual values, not with the containers ** used to hold those values. ** ** INVARIANTS: ** ** {F13761} A successful call to [sqlite3_column_decltype(S,N)] ** returns a zero-terminated UTF-8 string containing the ** the declared datatype of the table column that appears ** as the Nth column (numbered from 0) of the result set to the ** [prepared statement] S. ** ** {F13762} A successful call to [sqlite3_column_decltype16(S,N)] ** returns a zero-terminated UTF-16 native byte order string ** containing the declared datatype of the table column that appears ** as the Nth column (numbered from 0) of the result set to the ** [prepared statement] S. ** ** {F13763} If N is less than 0 or N is greater than or equal to ** the number of columns in [prepared statement] S ** or if the Nth column of S is an expression or subquery rather ** than a table column or if a memory allocation failure ** occurs during encoding conversions, then ** calls to [sqlite3_column_decltype(S,N)] or ** [sqlite3_column_decltype16(S,N)] return NULL. */ const char *sqlite3_column_decltype(sqlite3_stmt*,int); const void *sqlite3_column_decltype16(sqlite3_stmt*,int); /* ** CAPI3REF: Evaluate An SQL Statement {F13200} ** ** After an [prepared statement] has been prepared with a call ** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of ** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], ** then this function must be called one or more times to evaluate the ** statement. ** ** The details of the behavior of this sqlite3_step() interface depend ** on whether the statement was prepared using the newer "v2" interface ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy ** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the ** new "v2" interface is recommended for new applications but the legacy ** interface will continue to be supported. ** ** In the legacy interface, the return value will be either [SQLITE_BUSY], ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. ** With the "v2" interface, any of the other [SQLITE_OK | result code] ** or [SQLITE_IOERR_READ | extended result code] might be returned as ** well. ** ** [SQLITE_BUSY] means that the database engine was unable to acquire the ** database locks it needs to do its job. If the statement is a COMMIT ** or occurs outside of an explicit transaction, then you can retry the ** statement. If the statement is not a COMMIT and occurs within a ** explicit transaction then you should rollback the transaction before ** continuing. ** ** [SQLITE_DONE] means that the statement has finished executing ** successfully. sqlite3_step() should not be called again on this virtual ** machine without first calling [sqlite3_reset()] to reset the virtual ** machine back to its initial state. ** ** If the SQL statement being executed returns any data, then ** [SQLITE_ROW] is returned each time a new row of data is ready ** for processing by the caller. The values may be accessed using ** the [sqlite3_column_int | column access functions]. ** sqlite3_step() is called again to retrieve the next row of data. ** ** [SQLITE_ERROR] means that a run-time error (such as a constraint ** violation) has occurred. sqlite3_step() should not be called again on ** the VM. More information may be found by calling [sqlite3_errmsg()]. ** With the legacy interface, a more specific error code (example: ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) ** can be obtained by calling [sqlite3_reset()] on the ** [prepared statement]. In the "v2" interface, ** the more specific error code is returned directly by sqlite3_step(). ** ** [SQLITE_MISUSE] means that the this routine was called inappropriately. ** Perhaps it was called on a [prepared statement] that has ** already been [sqlite3_finalize | finalized] or on one that had ** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could ** be the case that the same database connection is being used by two or ** more threads at the same moment in time. ** ** <b>Goofy Interface Alert:</b> ** In the legacy interface, ** the sqlite3_step() API always returns a generic error code, ** [SQLITE_ERROR], following any error other than [SQLITE_BUSY] ** and [SQLITE_MISUSE]. You must call [sqlite3_reset()] or ** [sqlite3_finalize()] in order to find one of the specific ** [error codes] that better describes the error. ** We admit that this is a goofy design. The problem has been fixed ** with the "v2" interface. If you prepare all of your SQL statements ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the ** more specific [error codes] are returned directly ** by sqlite3_step(). The use of the "v2" interface is recommended. ** ** INVARIANTS: ** ** {F13202} If [prepared statement] S is ready to be ** run, then [sqlite3_step(S)] advances that prepared statement ** until to completion or until it is ready to return another ** row of the result set or an interrupt or run-time error occurs. ** ** {F15304} When a call to [sqlite3_step(S)] causes the ** [prepared statement] S to run to completion, ** the function returns [SQLITE_DONE]. ** ** {F15306} When a call to [sqlite3_step(S)] stops because it is ready ** to return another row of the result set, it returns ** [SQLITE_ROW]. ** ** {F15308} If a call to [sqlite3_step(S)] encounters an ** [sqlite3_interrupt|interrupt] or a run-time error, ** it returns an appropraite error code that is not one of ** [SQLITE_OK], [SQLITE_ROW], or [SQLITE_DONE]. ** ** {F15310} If an [sqlite3_interrupt|interrupt] or run-time error ** occurs during a call to [sqlite3_step(S)] ** for a [prepared statement] S created using ** legacy interfaces [sqlite3_prepare()] or ** [sqlite3_prepare16()] then the function returns either ** [SQLITE_ERROR], [SQLITE_BUSY], or [SQLITE_MISUSE]. */ int sqlite3_step(sqlite3_stmt*); /* ** CAPI3REF: Number of columns in a result set {F13770} ** ** Return the number of values in the current row of the result set. ** ** INVARIANTS: ** ** {F13771} After a call to [sqlite3_step(S)] that returns ** [SQLITE_ROW], the [sqlite3_data_count(S)] routine ** will return the same value as the ** [sqlite3_column_count(S)] function. ** ** {F13772} After [sqlite3_step(S)] has returned any value other than ** [SQLITE_ROW] or before [sqlite3_step(S)] has been ** called on the [prepared statement] for ** the first time since it was [sqlite3_prepare|prepared] ** or [sqlite3_reset|reset], the [sqlite3_data_count(S)] ** routine returns zero. */ int sqlite3_data_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Fundamental Datatypes {F10265} ** KEYWORDS: SQLITE_TEXT ** ** {F10266}Every value in SQLite has one of five fundamental datatypes: ** ** <ul> ** <li> 64-bit signed integer ** <li> 64-bit IEEE floating point number ** <li> string ** <li> BLOB ** <li> NULL ** </ul> {END} ** ** These constants are codes for each of those types. ** ** Note that the SQLITE_TEXT constant was also used in SQLite version 2 ** for a completely different meaning. Software that links against both ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not ** SQLITE_TEXT. */ #define SQLITE_INTEGER 1 #define SQLITE_FLOAT 2 #define SQLITE_BLOB 4 #define SQLITE_NULL 5 #ifdef SQLITE_TEXT ................................................................................ # undef SQLITE_TEXT #else # define SQLITE_TEXT 3 #endif #define SQLITE3_TEXT 3 /* ** CAPI3REF: Results Values From A Query {F13800} ** ** These routines form the "result set query" interface. ** ** These routines return information about ** a single column of the current result row of a query. In every ** case the first argument is a pointer to the ** [prepared statement] that is being ** evaluated (the [sqlite3_stmt*] that was returned from ** [sqlite3_prepare_v2()] or one of its variants) and ** the second argument is the index of the column for which information ** should be returned. The left-most column of the result set ** has an index of 0. ** ** If the SQL statement is not currently point to a valid row, or if the ** the column index is out of range, the result is undefined. ** These routines may only be called when the most recent call to ** [sqlite3_step()] has returned [SQLITE_ROW] and neither ** [sqlite3_reset()] nor [sqlite3_finalize()] has been call subsequently. ** If any of these routines are called after [sqlite3_reset()] or ** [sqlite3_finalize()] or after [sqlite3_step()] has returned ** something other than [SQLITE_ROW], the results are undefined. ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] ** are called from a different thread while any of these routines ** are pending, then the results are undefined. ** ** The sqlite3_column_type() routine returns ** [SQLITE_INTEGER | datatype code] for the initial data type ** of the result column. The returned value is one of [SQLITE_INTEGER], ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value ** returned by sqlite3_column_type() is only meaningful if no type ** conversions have occurred as described below. After a type conversion, ** the value returned by sqlite3_column_type() is undefined. Future ** versions of SQLite may change the behavior of sqlite3_column_type() ** following a type conversion. ** ** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() ** routine returns the number of bytes in that BLOB or string. ** If the result is a UTF-16 string, then sqlite3_column_bytes() converts ** the string to UTF-8 and then returns the number of bytes. ** If the result is a numeric value then sqlite3_column_bytes() uses ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns ** the number of bytes in that string. ** The value returned does not include the zero terminator at the end ** of the string. For clarity: the value returned is the number of ** bytes in the string, not the number of characters. ** ** Strings returned by sqlite3_column_text() and sqlite3_column_text16(), ** even empty strings, are always zero terminated. The return ** value from sqlite3_column_blob() for a zero-length blob is an arbitrary ** pointer, possibly even a NULL pointer. ** ** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() ** but leaves the result in UTF-16 in native byte order instead of UTF-8. ** The zero terminator is not included in this count. ** ** The object returned by [sqlite3_column_value()] is an ** [unprotected sqlite3_value] object. An unprotected sqlite3_value object ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. ** If the [unprotected sqlite3_value] object returned by ** [sqlite3_column_value()] is used in any other way, including calls ** to routines like ** [sqlite3_value_int()], [sqlite3_value_text()], or [sqlite3_value_bytes()], ** then the behavior is undefined. ** ** These routines attempt to convert the value where appropriate. For ** example, if the internal representation is FLOAT and a text result ** is requested, [sqlite3_snprintf()] is used internally to do the conversion ** automatically. The following table details the conversions that ** are applied: ** ** <blockquote> ** <table border="1"> ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion ** ** <tr><td> NULL <td> INTEGER <td> Result is 0 ** <tr><td> NULL <td> FLOAT <td> Result is 0.0 ** <tr><td> NULL <td> TEXT <td> Result is NULL pointer ** <tr><td> NULL <td> BLOB <td> Result is NULL pointer ** <tr><td> INTEGER <td> FLOAT <td> Convert from integer to float ** <tr><td> INTEGER <td> TEXT <td> ASCII rendering of the integer ** <tr><td> INTEGER <td> BLOB <td> Same as for INTEGER->TEXT ** <tr><td> FLOAT <td> INTEGER <td> Convert from float to integer ** <tr><td> FLOAT <td> TEXT <td> ASCII rendering of the float ** <tr><td> FLOAT <td> BLOB <td> Same as FLOAT->TEXT ** <tr><td> TEXT <td> INTEGER <td> Use atoi() ** <tr><td> TEXT <td> FLOAT <td> Use atof() ** <tr><td> TEXT <td> BLOB <td> No change ** <tr><td> BLOB <td> INTEGER <td> Convert to TEXT then use atoi() ................................................................................ ** <tr><td> BLOB <td> FLOAT <td> Convert to TEXT then use atof() ** <tr><td> BLOB <td> TEXT <td> Add a zero terminator if needed ** </table> ** </blockquote> ** ** The table above makes reference to standard C library functions atoi() ** and atof(). SQLite does not really use these functions. It has its ** on equavalent internal routines. The atoi() and atof() names are ** used in the table for brevity and because they are familiar to most ** C programmers. ** ** Note that when type conversions occur, pointers returned by prior ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or ** sqlite3_column_text16() may be invalidated. ** Type conversions and pointer invalidations might occur ** in the following cases: ** ** <ul> ** <li><p> The initial content is a BLOB and sqlite3_column_text() ** or sqlite3_column_text16() is called. A zero-terminator might ** need to be added to the string.</p></li> ** ** <li><p> The initial content is UTF-8 text and sqlite3_column_bytes16() or ** sqlite3_column_text16() is called. The content must be converted ** to UTF-16.</p></li> ** ** <li><p> The initial content is UTF-16 text and sqlite3_column_bytes() or ** sqlite3_column_text() is called. The content must be converted ** to UTF-8.</p></li> ** </ul> ** ** Conversions between UTF-16be and UTF-16le are always done in place and do ** not invalidate a prior pointer, though of course the content of the buffer ** that the prior pointer points to will have been modified. Other kinds ** of conversion are done in place when it is possible, but sometime it is ** not possible and in those cases prior pointers are invalidated. ** ** The safest and easiest to remember policy is to invoke these routines ** in one of the following ways: ** ** <ul> ** <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li> ** <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li> ** <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li> ** </ul> ** ** In other words, you should call sqlite3_column_text(), sqlite3_column_blob(), ** or sqlite3_column_text16() first to force the result into the desired ** format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to ** find the size of the result. Do not mix call to sqlite3_column_text() or ** sqlite3_column_blob() with calls to sqlite3_column_bytes16(). And do not ** mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes(). ** ** The pointers returned are valid until a type conversion occurs as ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or ** [sqlite3_finalize()] is called. The memory space used to hold strings ** and blobs is freed automatically. Do <b>not</b> pass the pointers returned ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into ** [sqlite3_free()]. ** ** If a memory allocation error occurs during the evaluation of any ** of these routines, a default value is returned. The default value ** is either the integer 0, the floating point number 0.0, or a NULL ** pointer. Subsequent calls to [sqlite3_errcode()] will return ** [SQLITE_NOMEM]. ** ** INVARIANTS: ** ** {F13803} The [sqlite3_column_blob(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a blob and then returns a ** pointer to the converted value. ** ** {F13806} The [sqlite3_column_bytes(S,N)] interface returns the ** number of bytes in the blob or string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_column_blob(S,N)] or ** [sqlite3_column_text(S,N)]. ** ** {F13809} The [sqlite3_column_bytes16(S,N)] interface returns the ** number of bytes in the string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_column_text16(S,N)]. ** ** {F13812} The [sqlite3_column_double(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a floating point value and ** returns a copy of that value. ** ** {F13815} The [sqlite3_column_int(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a 64-bit signed integer and ** returns the lower 32 bits of that integer. ** ** {F13818} The [sqlite3_column_int64(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a 64-bit signed integer and ** returns a copy of that integer. ** ** {F13821} The [sqlite3_column_text(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a zero-terminated UTF-8 ** string and returns a pointer to that string. ** ** {F13824} The [sqlite3_column_text16(S,N)] interface converts the ** Nth column in the current row of the result set for ** [prepared statement] S into a zero-terminated 2-byte ** aligned UTF-16 native byte order ** string and returns a pointer to that string. ** ** {F13827} The [sqlite3_column_type(S,N)] interface returns ** one of [SQLITE_NULL], [SQLITE_INTEGER], [SQLITE_FLOAT], ** [SQLITE_TEXT], or [SQLITE_BLOB] as appropriate for ** the Nth column in the current row of the result set for ** [prepared statement] S. ** ** {F13830} The [sqlite3_column_value(S,N)] interface returns a ** pointer to an [unprotected sqlite3_value] object for the ** Nth column in the current row of the result set for ** [prepared statement] S. */ const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); int sqlite3_column_bytes(sqlite3_stmt*, int iCol); int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); double sqlite3_column_double(sqlite3_stmt*, int iCol); int sqlite3_column_int(sqlite3_stmt*, int iCol); sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); ................................................................................ const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); /* ** CAPI3REF: Destroy A Prepared Statement Object {F13300} ** ** The sqlite3_finalize() function is called to delete a ** [prepared statement]. If the statement was ** executed successfully, or not executed at all, then SQLITE_OK is returned. ** If execution of the statement failed then an ** [error code] or [extended error code] ** is returned. ** ** This routine can be called at any point during the execution of the ** [prepared statement]. If the virtual machine has not ** completed execution when this routine is called, that is like ** encountering an error or an interrupt. (See [sqlite3_interrupt()].) ** Incomplete updates may be rolled back and transactions cancelled, ** depending on the circumstances, and the ** [error code] returned will be [SQLITE_ABORT]. ** ** INVARIANTS: ** ** {F11302} The [sqlite3_finalize(S)] interface destroys the ** [prepared statement] S and releases all ** memory and file resources held by that object. ................................................................................ ** then [sqlite3_finalize(S)] returns that same error. */ int sqlite3_finalize(sqlite3_stmt *pStmt); /* ** CAPI3REF: Reset A Prepared Statement Object {F13330} ** ** The sqlite3_reset() function is called to reset a ** [prepared statement] object. ** back to its initial state, ready to be re-executed. ** Any SQL statement variables that had values bound to them using ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. ** Use [sqlite3_clear_bindings()] to reset the bindings. ** ** {F11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S ** back to the beginning of its program. ** ** {F11334} If the most recent call to [sqlite3_step(S)] for ** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], ** or if [sqlite3_step(S)] has never before been called on S, ** then [sqlite3_reset(S)] returns [SQLITE_OK]. ** ** {F11336} If the most recent call to [sqlite3_step(S)] for ** [prepared statement] S indicated an error, then ** [sqlite3_reset(S)] returns an appropriate [error code]. ** ** {F11338} The [sqlite3_reset(S)] interface does not change the values ** of any [sqlite3_bind_blob|bindings] on [prepared statement] S. */ int sqlite3_reset(sqlite3_stmt *pStmt); /* ** CAPI3REF: Create Or Redefine SQL Functions {F16100} ** KEYWORDS: {function creation routines} ** ** These two functions (collectively known as ** "function creation routines") are used to add SQL functions or aggregates ** or to redefine the behavior of existing SQL functions or aggregates. The ** difference only between the two is that the second parameter, the ** name of the (scalar) function or aggregate, is encoded in UTF-8 for ** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). ** ** The first parameter is the [database connection] to which the SQL ** function is to be added. If a single ** program uses more than one [database connection] internally, then SQL ** functions must be added individually to each [database connection]. ** ** The second parameter is the name of the SQL function to be created ** or redefined. ** The length of the name is limited to 255 bytes, exclusive of the ** zero-terminator. Note that the name length limit is in bytes, not ** characters. Any attempt to create a function with a longer name ** will result in an SQLITE_ERROR error. ** ** The third parameter is the number of arguments that the SQL function or ** aggregate takes. If this parameter is negative, then the SQL function or ** aggregate may take any number of arguments. ** ** The fourth parameter, eTextRep, specifies what ** [SQLITE_UTF8 | text encoding] this SQL function prefers for ** its parameters. Any SQL function implementation should be able to work ** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be ** more efficient with one encoding than another. It is allowed to ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple ** times with the same function but with different values of eTextRep. ** When multiple implementations of the same function are available, SQLite ** will pick the one that involves the least amount of data conversion. ** If there is only a single implementation which does not care what ** text encoding is used, then the fourth argument should be ** [SQLITE_ANY]. ** ** The fifth parameter is an arbitrary pointer. The implementation ** of the function can gain access to this pointer using ** [sqlite3_user_data()]. ** ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are ** pointers to C-language functions that implement the SQL ** function or aggregate. A scalar SQL function requires an implementation of ** the xFunc callback only, NULL pointers should be passed as the xStep ** and xFinal parameters. An aggregate SQL function requires an implementation ** of xStep and xFinal and NULL should be passed for xFunc. To delete an ** existing SQL function or aggregate, pass NULL for all three function ** callback. ** ** It is permitted to register multiple implementations of the same ** functions with the same name but with either differing numbers of ** arguments or differing perferred text encodings. SQLite will use ** the implementation most closely matches the way in which the ** SQL function is used. ** ** INVARIANTS: ** ** {F16103} The [sqlite3_create_function16()] interface behaves exactly ** like [sqlite3_create_function()] in every way except that it ** interprets the zFunctionName argument as ** zero-terminated UTF-16 native byte order instead of as a ** zero-terminated UTF-8. ** ** {F16106} A successful invocation of ** the [sqlite3_create_function(D,X,N,E,...)] interface registers ** or replaces callback functions in [database connection] D ** used to implement the SQL function named X with N parameters ** and having a perferred text encoding of E. ** ** {F16109} A successful call to [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** replaces the P, F, S, and L values from any prior calls with ** the same D, X, N, and E values. ** ** {F16112} The [sqlite3_create_function(D,X,...)] interface fails with ** a return code of [SQLITE_ERROR] if the SQL function name X is ................................................................................ ** {F16136} When calls to [sqlite3_create_function(D,X,N,E,...)] ** specify multiple implementations of the same function X with ** the same number of arguments N but with different ** encodings E, then the implementation where E matches the ** database encoding is preferred. ** ** {F16139} For an aggregate SQL function created using ** [sqlite3_create_function(D,X,N,E,P,0,S,L)] the finializer ** function L will always be invoked exactly once if the ** step function S is called one or more times. ** ** {F16142} When SQLite invokes either the xFunc or xStep function of ** an application-defined SQL function or aggregate created ** by [sqlite3_create_function()] or [sqlite3_create_function16()], ** then the array of [sqlite3_value] objects passed as the ................................................................................ ** each parameter to the SQL function. These routines are used to ** extract values from the [sqlite3_value] objects. ** ** These routines work only with [protected sqlite3_value] objects. ** Any attempt to use these routines on an [unprotected sqlite3_value] ** object results in undefined behavior. ** ** These routines work just like the corresponding ** [sqlite3_column_blob | sqlite3_column_* routines] except that ** these routines take a single [protected sqlite3_value] object pointer ** instead of an [sqlite3_stmt*] pointer and an integer column number. ** ** The sqlite3_value_text16() interface extracts a UTF16 string ** in the native byte-order of the host machine. The ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces ** extract UTF16 strings as big-endian and little-endian respectively. ** ** The sqlite3_value_numeric_type() interface attempts to apply ** numeric affinity to the value. This means that an attempt is ** made to convert the value to an integer or floating point. If ** such a conversion is possible without loss of information (in other ** words if the value is a string that looks like a number) ** then the conversion is done. Otherwise no conversion occurs. The ** [SQLITE_INTEGER | datatype] after conversion is returned. ** ** Please pay particular attention to the fact that the pointer that ** is returned from [sqlite3_value_blob()], [sqlite3_value_text()], or ** [sqlite3_value_text16()] can be invalidated by a subsequent call to ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], ** or [sqlite3_value_text16()]. ** ** These routines must be called from the same thread as ** the SQL function that supplied the [sqlite3_value*] parameters. ** ** ** INVARIANTS: ** ** {F15103} The [sqlite3_value_blob(V)] interface converts the ** [protected sqlite3_value] object V into a blob and then returns a ** pointer to the converted value. ** ** {F15106} The [sqlite3_value_bytes(V)] interface returns the ** number of bytes in the blob or string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_value_blob(V)] or ** [sqlite3_value_text(V)]. ** ** {F15109} The [sqlite3_value_bytes16(V)] interface returns the ** number of bytes in the string (exclusive of the ** zero terminator on the string) that was returned by the ................................................................................ ** returns the lower 32 bits of that integer. ** ** {F15118} The [sqlite3_value_int64(V)] interface converts the ** [protected sqlite3_value] object V into a 64-bit signed integer and ** returns a copy of that integer. ** ** {F15121} The [sqlite3_value_text(V)] interface converts the ** [protected sqlite3_value] object V into a zero-terminated UTF-8 ** string and returns a pointer to that string. ** ** {F15124} The [sqlite3_value_text16(V)] interface converts the ** [protected sqlite3_value] object V into a zero-terminated 2-byte ** aligned UTF-16 native byte order ** string and returns a pointer to that string. ** ................................................................................ ** the [sqlite3_value] object V. ** ** {F15136} The [sqlite3_value_numeric_type(V)] interface converts ** the [protected sqlite3_value] object V into either an integer or ** a floating point value if it can do so without loss of ** information, and returns one of [SQLITE_NULL], ** [SQLITE_INTEGER], [SQLITE_FLOAT], [SQLITE_TEXT], or ** [SQLITE_BLOB] as appropriate for ** the [protected sqlite3_value] object V after the conversion attempt. */ const void *sqlite3_value_blob(sqlite3_value*); int sqlite3_value_bytes(sqlite3_value*); int sqlite3_value_bytes16(sqlite3_value*); double sqlite3_value_double(sqlite3_value*); int sqlite3_value_int(sqlite3_value*); sqlite3_int64 sqlite3_value_int64(sqlite3_value*); ................................................................................ int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); /* ** CAPI3REF: Obtain Aggregate Function Context {F16210} ** ** The implementation of aggregate SQL functions use this routine to allocate ** a structure for storing their state. ** The first time the sqlite3_aggregate_context() routine is ** is called for a particular aggregate, SQLite allocates nBytes of memory ** zeros that memory, and returns a pointer to it. ** On second and subsequent calls to sqlite3_aggregate_context() ** for the same aggregate function index, the same buffer is returned. ** The implementation ** of the aggregate can use the returned buffer to accumulate data. ** ** SQLite automatically frees the allocated buffer when the aggregate ** query concludes. ** ** The first parameter should be a copy of the ** [sqlite3_context | SQL function context] that is the first ** parameter to the callback routine that implements the aggregate ** function. ** ** This routine must be called from the same thread in which ** the aggregate SQL function is running. ** ** INVARIANTS: ** ** {F16211} The first invocation of [sqlite3_aggregate_context(C,N)] for ** a particular instance of an aggregate function (for a particular ** context C) causes SQLite to allocation N bytes of memory, ** zero that memory, and return a pointer to the allocationed ** memory. ** ** {F16213} If a memory allocation error occurs during ** [sqlite3_aggregate_context(C,N)] then the function returns 0. ** ** {F16215} Second and subsequent invocations of ** [sqlite3_aggregate_context(C,N)] for the same context pointer C ** ignore the N parameter and return a pointer to the same ................................................................................ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); /* ** CAPI3REF: User Data For Functions {F16240} ** ** The sqlite3_user_data() interface returns a copy of ** the pointer that was the pUserData parameter (the 5th parameter) ** of the the [sqlite3_create_function()] ** and [sqlite3_create_function16()] routines that originally ** registered the application defined function. {END} ** ** This routine must be called from the same thread in which ** the application-defined function is running. ** ** INVARIANTS: ** ** {F16243} The [sqlite3_user_data(C)] interface returns a copy of the ** P pointer from the [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** or [sqlite3_create_function16(D,X,N,E,P,F,S,L)] call that ** registered the SQL function associated with ** [sqlite3_context] C. */ void *sqlite3_user_data(sqlite3_context*); /* ** CAPI3REF: Database Connection For Functions {F16250} ** ** The sqlite3_context_db_handle() interface returns a copy of ** the pointer to the [database connection] (the 1st parameter) ** of the the [sqlite3_create_function()] ** and [sqlite3_create_function16()] routines that originally ** registered the application defined function. ** ** INVARIANTS: ** ** {F16253} The [sqlite3_context_db_handle(C)] interface returns a copy of the ** D pointer from the [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** or [sqlite3_create_function16(D,X,N,E,P,F,S,L)] call that ** registered the SQL function associated with ** [sqlite3_context] C. */ sqlite3 *sqlite3_context_db_handle(sqlite3_context*); /* ** CAPI3REF: Function Auxiliary Data {F16270} ** ** The following two functions may be used by scalar SQL functions to ** associate meta-data with argument values. If the same value is passed to ** multiple invocations of the same SQL function during query execution, under ** some circumstances the associated meta-data may be preserved. This may ** be used, for example, to add a regular-expression matching scalar ** function. The compiled version of the regular expression is stored as ** meta-data associated with the SQL value passed as the regular expression ** pattern. The compiled regular expression can be reused on multiple ** invocations of the same function so that the original pattern string ** does not need to be recompiled on each invocation. ** ** The sqlite3_get_auxdata() interface returns a pointer to the meta-data ** associated by the sqlite3_set_auxdata() function with the Nth argument ** value to the application-defined function. ** If no meta-data has been ever been set for the Nth ** argument of the function, or if the cooresponding function parameter ** has changed since the meta-data was set, then sqlite3_get_auxdata() ** returns a NULL pointer. ** ** The sqlite3_set_auxdata() interface saves the meta-data ** pointed to by its 3rd parameter as the meta-data for the N-th ** argument of the application-defined function. Subsequent ** calls to sqlite3_get_auxdata() might return this data, if it has ** not been destroyed. ** If it is not NULL, SQLite will invoke the destructor ** function given by the 4th parameter to sqlite3_set_auxdata() on ** the meta-data when the corresponding function parameter changes ** or when the SQL statement completes, whichever comes first. ** ** SQLite is free to call the destructor and drop meta-data on ** any parameter of any function at any time. The only guarantee ** is that the destructor will be called before the metadata is ** dropped. ** ** In practice, meta-data is preserved between function calls for ** expressions that are constant at compile time. This includes literal ** values and SQL variables. ** ** These routines must be called from the same thread in which ** the SQL function is running. ** ** INVARIANTS: ................................................................................ ** ** {F16272} The [sqlite3_get_auxdata(C,N)] interface returns a pointer ** to metadata associated with the Nth parameter of the SQL function ** whose context is C, or NULL if there is no metadata associated ** with that parameter. ** ** {F16274} The [sqlite3_set_auxdata(C,N,P,D)] interface assigns a metadata ** pointer P to the Nth parameter of the SQL function with context ** C. ** ** {F16276} SQLite will invoke the destructor D with a single argument ** which is the metadata pointer P following a call to ** [sqlite3_set_auxdata(C,N,P,D)] when SQLite ceases to hold ** the metadata. ** ** {F16277} SQLite ceases to hold metadata for an SQL function parameter ................................................................................ void *sqlite3_get_auxdata(sqlite3_context*, int N); void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); /* ** CAPI3REF: Constants Defining Special Destructor Behavior {F10280} ** ** These are special value for the destructor that is passed in as the ** final argument to routines like [sqlite3_result_blob()]. If the destructor ** argument is SQLITE_STATIC, it means that the content pointer is constant ** and will never change. It does not need to be destroyed. The ** SQLITE_TRANSIENT value means that the content will likely change in ** the near future and that SQLite should make its own private copy of ** the content before returning. ** ** The typedef is necessary to work around problems in certain ** C++ compilers. See ticket #2191. */ ................................................................................ ** CAPI3REF: Setting The Result Of An SQL Function {F16400} ** ** These routines are used by the xFunc or xFinal callbacks that ** implement SQL functions and aggregates. See ** [sqlite3_create_function()] and [sqlite3_create_function16()] ** for additional information. ** ** These functions work very much like the ** [sqlite3_bind_blob | sqlite3_bind_*] family of functions used ** to bind values to host parameters in prepared statements. ** Refer to the ** [sqlite3_bind_blob | sqlite3_bind_* documentation] for ** additional information. ** ** The sqlite3_result_blob() interface sets the result from ** an application defined function to be the BLOB whose content is pointed ** to by the second parameter and which is N bytes long where N is the ** third parameter. ** The sqlite3_result_zeroblob() inerfaces set the result of ** the application defined function to be a BLOB containing all zero ** bytes and N bytes in size, where N is the value of the 2nd parameter. ** ** The sqlite3_result_double() interface sets the result from ** an application defined function to be a floating point value specified ** by its 2nd argument. ** ** The sqlite3_result_error() and sqlite3_result_error16() functions ** cause the implemented SQL function to throw an exception. ** SQLite uses the string pointed to by the ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() ** as the text of an error message. SQLite interprets the error ** message string from sqlite3_result_error() as UTF8. SQLite ** interprets the string from sqlite3_result_error16() as UTF16 in native ** byte order. If the third parameter to sqlite3_result_error() ** or sqlite3_result_error16() is negative then SQLite takes as the error ** message all text up through the first zero character. ** If the third parameter to sqlite3_result_error() or ** sqlite3_result_error16() is non-negative then SQLite takes that many ** bytes (not characters) from the 2nd parameter as the error message. ** The sqlite3_result_error() and sqlite3_result_error16() ** routines make a copy private copy of the error message text before ** they return. Hence, the calling function can deallocate or ** modify the text after they return without harm. ** The sqlite3_result_error_code() function changes the error code ** returned by SQLite as a result of an error in a function. By default, ** the error code is SQLITE_ERROR. A subsequent call to sqlite3_result_error() ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. ** ** The sqlite3_result_toobig() interface causes SQLite ** to throw an error indicating that a string or BLOB is to long ** to represent. The sqlite3_result_nomem() interface ** causes SQLite to throw an exception indicating that the a ** memory allocation failed. ** ** The sqlite3_result_int() interface sets the return value ** of the application-defined function to be the 32-bit signed integer ** value given in the 2nd argument. ** The sqlite3_result_int64() interface sets the return value ** of the application-defined function to be the 64-bit signed integer ** value given in the 2nd argument. ** ** The sqlite3_result_null() interface sets the return value ** of the application-defined function to be NULL. ** ** The sqlite3_result_text(), sqlite3_result_text16(), ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces ** set the return value of the application-defined function to be ** a text string which is represented as UTF-8, UTF-16 native byte order, ** UTF-16 little endian, or UTF-16 big endian, respectively. ** SQLite takes the text result from the application from ** the 2nd parameter of the sqlite3_result_text* interfaces. ** If the 3rd parameter to the sqlite3_result_text* interfaces ** is negative, then SQLite takes result text from the 2nd parameter ** through the first zero character. ** If the 3rd parameter to the sqlite3_result_text* interfaces ** is non-negative, then as many bytes (not characters) of the text ** pointed to by the 2nd parameter are taken as the application-defined ** function result. ** If the 4th parameter to the sqlite3_result_text* interfaces ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that ** function as the destructor on the text or blob result when it has ** finished using that result. ** If the 4th parameter to the sqlite3_result_text* interfaces ** or sqlite3_result_blob is the special constant SQLITE_STATIC, then ** SQLite assumes that the text or blob result is constant space and ** does not copy the space or call a destructor when it has ** finished using that result. ** If the 4th parameter to the sqlite3_result_text* interfaces ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT ** then SQLite makes a copy of the result into space obtained from ** from [sqlite3_malloc()] before it returns. ** ** The sqlite3_result_value() interface sets the result of ** the application-defined function to be a copy the ** [unprotected sqlite3_value] object specified by the 2nd parameter. The ** sqlite3_result_value() interface makes a copy of the [sqlite3_value] ** so that [sqlite3_value] specified in the parameter may change or ** be deallocated after sqlite3_result_value() returns without harm. ** A [protected sqlite3_value] object may always be used where an ** [unprotected sqlite3_value] object is required, so either ** kind of [sqlite3_value] object can be used with this interface. ** ** If these routines are called from within the different thread ** than the one containing the application-defined function that recieved ** the [sqlite3_context] pointer, the results are undefined. ** ** INVARIANTS: ** ** {F16403} The default return value from any SQL function is NULL. ** ** {F16406} The [sqlite3_result_blob(C,V,N,D)] interface changes the ** return value of function C to be a blob that is N bytes ** in length and with content pointed to by V. ** ** {F16409} The [sqlite3_result_double(C,V)] interface changes the ** return value of function C to be the floating point value V. ** ** {F16412} The [sqlite3_result_error(C,V,N)] interface changes the return ** value of function C to be an exception with error code ** [SQLITE_ERROR] and a UTF8 error message copied from V up to the ** first zero byte or until N bytes are read if N is positive. ** ** {F16415} The [sqlite3_result_error16(C,V,N)] interface changes the return ** value of function C to be an exception with error code ** [SQLITE_ERROR] and a UTF16 native byte order error message ** copied from V up to the first zero terminator or until N bytes ** are read if N is positive. ** ** {F16418} The [sqlite3_result_error_toobig(C)] interface changes the return ** value of the function C to be an exception with error code ** [SQLITE_TOOBIG] and an appropriate error message. ** ................................................................................ ** {F16430} The [sqlite3_result_int64(C,V)] interface changes the ** return value of function C to be the 64-bit integer value V. ** ** {F16433} The [sqlite3_result_null(C)] interface changes the ** return value of function C to be NULL. ** ** {F16436} The [sqlite3_result_text(C,V,N,D)] interface changes the ** return value of function C to be the UTF8 string ** V up to the first zero if N is negative ** or the first N bytes of V if N is non-negative. ** ** {F16439} The [sqlite3_result_text16(C,V,N,D)] interface changes the ** return value of function C to be the UTF16 native byte order ** string V up to the first zero if N is ** negative or the first N bytes of V if N is non-negative. ** ** {F16442} The [sqlite3_result_text16be(C,V,N,D)] interface changes the ** return value of function C to be the UTF16 big-endian ** string V up to the first zero if N is ** is negative or the first N bytes or V if N is non-negative. ** ** {F16445} The [sqlite3_result_text16le(C,V,N,D)] interface changes the ** return value of function C to be the UTF16 little-endian ** string V up to the first zero if N is ** negative or the first N bytes of V if N is non-negative. ** ** {F16448} The [sqlite3_result_value(C,V)] interface changes the ** return value of function C to be [unprotected sqlite3_value] ** object V. ** ** {F16451} The [sqlite3_result_zeroblob(C,N)] interface changes the ** return value of function C to be an N-byte blob of all zeros. ** ** {F16454} The [sqlite3_result_error()] and [sqlite3_result_error16()] ** interfaces make a copy of their error message strings before ** returning. ** ** {F16457} If the D destructor parameter to [sqlite3_result_blob(C,V,N,D)], ** [sqlite3_result_text(C,V,N,D)], [sqlite3_result_text16(C,V,N,D)], ................................................................................ ** [SQLITE_TRANSIENT] then the interfaces makes a copy of the ** content of V and retains the copy. ** ** {F16463} If the D destructor parameter to [sqlite3_result_blob(C,V,N,D)], ** [sqlite3_result_text(C,V,N,D)], [sqlite3_result_text16(C,V,N,D)], ** [sqlite3_result_text16be(C,V,N,D)], or ** [sqlite3_result_text16le(C,V,N,D)] is some value other than ** the constants [SQLITE_STATIC] and [SQLITE_TRANSIENT] then ** SQLite will invoke the destructor D with V as its only argument ** when it has finished with the V value. */ void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); void sqlite3_result_double(sqlite3_context*, double); void sqlite3_result_error(sqlite3_context*, const char*, int); void sqlite3_result_error16(sqlite3_context*, const void*, int); ................................................................................ void sqlite3_result_value(sqlite3_context*, sqlite3_value*); void sqlite3_result_zeroblob(sqlite3_context*, int n); /* ** CAPI3REF: Define New Collating Sequences {F16600} ** ** These functions are used to add new collation sequences to the ** [sqlite3*] handle specified as the first argument. ** ** The name of the new collation sequence is specified as a UTF-8 string ** for sqlite3_create_collation() and sqlite3_create_collation_v2() ** and a UTF-16 string for sqlite3_create_collation16(). In all cases ** the name is passed as the second function argument. ** ** The third argument may be one of the constants [SQLITE_UTF8], ** [SQLITE_UTF16LE] or [SQLITE_UTF16BE], indicating that the user-supplied ** routine expects to be passed pointers to strings encoded using UTF-8, ** UTF-16 little-endian or UTF-16 big-endian respectively. The ** third argument might also be [SQLITE_UTF16_ALIGNED] to indicate that ** the routine expects pointers to 16-bit word aligned strings ** of UTF16 in the native byte order of the host computer. ** ** A pointer to the user supplied routine must be passed as the fifth ** argument. If it is NULL, this is the same as deleting the collation ** sequence (so that SQLite cannot call it anymore). ** Each time the application ** supplied function is invoked, it is passed a copy of the void* passed as ** the fourth argument to sqlite3_create_collation() or ** sqlite3_create_collation16() as its first parameter. ** ** The remaining arguments to the application-supplied routine are two strings, ** each represented by a (length, data) pair and encoded in the encoding ** that was passed as the third argument when the collation sequence was ** registered. {END} The application defined collation routine should ** return negative, zero or positive if ** the first string is less than, equal to, or greater than the second ** string. i.e. (STRING1 - STRING2). ** ** The sqlite3_create_collation_v2() works like sqlite3_create_collation() ** excapt that it takes an extra argument which is a destructor for ** the collation. The destructor is called when the collation is ** destroyed and is passed a copy of the fourth parameter void* pointer ** of the sqlite3_create_collation_v2(). ** Collations are destroyed when ** they are overridden by later calls to the collation creation functions ** or when the [sqlite3*] database handle is closed using [sqlite3_close()]. ** ** INVARIANTS: ** ** {F16603} A successful call to the ** [sqlite3_create_collation_v2(B,X,E,P,F,D)] interface ** registers function F as the comparison function used to ** implement collation X on [database connection] B for ** databases having encoding E. ** ** {F16604} SQLite understands the X parameter to ** [sqlite3_create_collation_v2(B,X,E,P,F,D)] as a zero-terminated ** UTF-8 string in which case is ignored for ASCII characters and ** is significant for non-ASCII characters. ** ** {F16606} Successive calls to [sqlite3_create_collation_v2(B,X,E,P,F,D)] ** with the same values for B, X, and E, override prior values ** of P, F, and D. ** ** {F16609} The destructor D in [sqlite3_create_collation_v2(B,X,E,P,F,D)] ** is not NULL then it is called with argument P when the ** collating function is dropped by SQLite. ** ** {F16612} A collating function is dropped when it is overloaded. ** ** {F16615} A collating function is dropped when the database connection ** is closed using [sqlite3_close()]. ................................................................................ ** ** {F16621} A call to [sqlite3_create_collation(B,X,E,P,F)] is exactly ** the same as a call to [sqlite3_create_collation_v2()] with ** the same parameters and a NULL destructor. ** ** {F16624} Following a [sqlite3_create_collation_v2(B,X,E,P,F,D)], ** SQLite uses the comparison function F for all text comparison ** operations on [database connection] B on text values that ** use the collating sequence name X. ** ** {F16627} The [sqlite3_create_collation16(B,X,E,P,F)] works the same ** as [sqlite3_create_collation(B,X,E,P,F)] except that the ** collation name X is understood as UTF-16 in native byte order ** instead of UTF-8. ** ** {F16630} When multiple comparison functions are available for the same ................................................................................ int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*), void(*xDestroy)(void*) ); int sqlite3_create_collation16( sqlite3*, const char *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); /* ** CAPI3REF: Collation Needed Callbacks {F16700} ** ** To avoid having to register all collation sequences before a database ** can be used, a single callback function may be registered with the ** database handle to be called whenever an undefined collation sequence is ** required. ** ** If the function is registered using the sqlite3_collation_needed() API, ** then it is passed the names of undefined collation sequences as strings ** encoded in UTF-8. {F16703} If sqlite3_collation_needed16() is used, the names ** are passed as UTF-16 in machine native byte order. A call to either ** function replaces any existing callback. ** ** When the callback is invoked, the first argument passed is a copy ** of the second argument to sqlite3_collation_needed() or ** sqlite3_collation_needed16(). The second argument is the database ** handle. The third argument is one of [SQLITE_UTF8], ** [SQLITE_UTF16BE], or [SQLITE_UTF16LE], indicating the most ** desirable form of the collation sequence function required. ** The fourth parameter is the name of the ** required collation sequence. ** ** The callback function should register the desired collation using ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or ** [sqlite3_create_collation_v2()]. ** ** INVARIANTS: ................................................................................ ** interface. ** ** {F16706} The name of the requested collating function passed in the ** 4th parameter to the callback is in UTF-8 if the callback ** was registered using [sqlite3_collation_needed()] and ** is in UTF-16 native byte order if the callback was ** registered using [sqlite3_collation_needed16()]. ** ** */ int sqlite3_collation_needed( sqlite3*, void*, void(*)(void*,sqlite3*,int eTextRep,const char*) ); int sqlite3_collation_needed16( ................................................................................ */ int sqlite3_rekey( sqlite3 *db, /* Database to be rekeyed */ const void *pKey, int nKey /* The new key */ ); /* ** CAPI3REF: Suspend Execution For A Short Time {F10530} ** ** The sqlite3_sleep() function ** causes the current thread to suspend execution ** for at least a number of milliseconds specified in its parameter. ** ** If the operating system does not support sleep requests with ** millisecond time resolution, then the time will be rounded up to ** the nearest second. The number of milliseconds of sleep actually ** requested from the operating system is returned. ** ** SQLite implements this interface by calling the xSleep() ** method of the default [sqlite3_vfs] object. ** ** INVARIANTS: ** ................................................................................ ** {F10536} The [sqlite3_sleep(M)] interface returns the number of ** milliseconds of sleep actually requested of the operating ** system, which might be larger than the parameter M. */ int sqlite3_sleep(int); /* ** CAPI3REF: Name Of The Folder Holding Temporary Files {F10310} ** ** If this global variable is made to point to a string which is ** the name of a folder (a.ka. directory), then all temporary files ** created by SQLite will be placed in that directory. If this variable ** is NULL pointer, then SQLite does a search for an appropriate temporary ** file directory. ** ** It is not safe to modify this variable once a database connection ** has been opened. It is intended that this variable be set once ** as part of process initialization and before any SQLite interface ** routines have been call and remain unchanged thereafter. */ SQLITE_EXTERN char *sqlite3_temp_directory; /* ** CAPI3REF: Test To See If The Database Is In Auto-Commit Mode {F12930} ** ** The sqlite3_get_autocommit() interfaces returns non-zero or ** zero if the given database connection is or is not in autocommit mode, ** respectively. Autocommit mode is on ** by default. Autocommit mode is disabled by a [BEGIN] statement. ** Autocommit mode is reenabled by a [COMMIT] or [ROLLBACK]. ** ** If certain kinds of errors occur on a statement within a multi-statement ** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the ** transaction might be rolled back automatically. The only way to ** find out if SQLite automatically rolled back the transaction after ** an error is to use this function. ** ** INVARIANTS: ** ** {F12931} The [sqlite3_get_autocommit(D)] interface returns non-zero or ** zero if the [database connection] D is or is not in autocommit ** mode, respectively. ................................................................................ ** ** {F12932} Autocommit mode is on by default. ** ** {F12933} Autocommit mode is disabled by a successful [BEGIN] statement. ** ** {F12934} Autocommit mode is enabled by a successful [COMMIT] or [ROLLBACK] ** statement. ** ** ** LIMITATIONS: *** ** {U12936} If another thread changes the autocommit status of the database ** connection while this routine is running, then the return value ** is undefined. */ int sqlite3_get_autocommit(sqlite3*); /* ** CAPI3REF: Find The Database Handle Of A Prepared Statement {F13120} ** ** The sqlite3_db_handle interface ** returns the [sqlite3*] database handle to which a ** [prepared statement] belongs. ** The database handle returned by sqlite3_db_handle ** is the same database handle that was ** the first argument to the [sqlite3_prepare_v2()] or its variants ** that was used to create the statement in the first place. ** ** INVARIANTS: ** ** {F13123} The [sqlite3_db_handle(S)] interface returns a pointer ** to the [database connection] associated with ** [prepared statement] S. */ sqlite3 *sqlite3_db_handle(sqlite3_stmt*); /* ** CAPI3REF: Commit And Rollback Notification Callbacks {F12950} ** ** The sqlite3_commit_hook() interface registers a callback ** function to be invoked whenever a transaction is committed. ** Any callback set by a previous call to sqlite3_commit_hook() ** for the same database connection is overridden. ** The sqlite3_rollback_hook() interface registers a callback ** function to be invoked whenever a transaction is committed. ** Any callback set by a previous call to sqlite3_commit_hook() ** for the same database connection is overridden. ** The pArg argument is passed through ** to the callback. If the callback on a commit hook function ** returns non-zero, then the commit is converted into a rollback. ** ** If another function was previously registered, its ** pArg value is returned. Otherwise NULL is returned. ** ** Registering a NULL function disables the callback. ** ** For the purposes of this API, a transaction is said to have been ** rolled back if an explicit "ROLLBACK" statement is executed, or ** an error or constraint causes an implicit rollback to occur. ** The rollback callback is not invoked if a transaction is ** automatically rolled back because the database connection is closed. ** The rollback callback is not invoked if a transaction is ** rolled back because a commit callback returned non-zero. ** <todo> Check on this </todo> ** ** These are experimental interfaces and are subject to change. ** ** INVARIANTS: ** ** {F12951} The [sqlite3_commit_hook(D,F,P)] interface registers the ** callback function F to be invoked with argument P whenever ** a transaction commits on [database connection] D. ** ** {F12952} The [sqlite3_commit_hook(D,F,P)] interface returns the P ** argument from the previous call with the same ** [database connection ] D , or NULL on the first call ** for a particular [database connection] D. ** ** {F12953} Each call to [sqlite3_commit_hook()] overwrites the callback ** registered by prior calls. ** ** {F12954} If the F argument to [sqlite3_commit_hook(D,F,P)] is NULL ** then the commit hook callback is cancelled and no callback ** is invoked when a transaction commits. ** ** {F12955} If the commit callback returns non-zero then the commit is ** converted into a rollback. ** ** {F12961} The [sqlite3_rollback_hook(D,F,P)] interface registers the ** callback function F to be invoked with argument P whenever ** a transaction rolls back on [database connection] D. ** ** {F12962} The [sqlite3_rollback_hook(D,F,P)] interface returns the P ** argument from the previous call with the same ** [database connection ] D , or NULL on the first call ** for a particular [database connection] D. ** ** {F12963} Each call to [sqlite3_rollback_hook()] overwrites the callback ** registered by prior calls. ** ** {F12964} If the F argument to [sqlite3_rollback_hook(D,F,P)] is NULL ** then the rollback hook callback is cancelled and no callback ** is invoked when a transaction rolls back. */ void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); /* ** CAPI3REF: Data Change Notification Callbacks {F12970} ** ** The sqlite3_update_hook() interface ** registers a callback function with the database connection identified by the ** first argument to be invoked whenever a row is updated, inserted or deleted. ** Any callback set by a previous call to this function for the same ** database connection is overridden. ** ** The second argument is a pointer to the function to invoke when a ** row is updated, inserted or deleted. ** The first argument to the callback is ** a copy of the third argument to sqlite3_update_hook(). ** The second callback ** argument is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], ** depending on the operation that caused the callback to be invoked. ** The third and ** fourth arguments to the callback contain pointers to the database and ** table name containing the affected row. ** The final callback parameter is ** the rowid of the row. ** In the case of an update, this is the rowid after ** the update takes place. ** ** The update hook is not invoked when internal system tables are ** modified (i.e. sqlite_master and sqlite_sequence). ** ** If another function was previously registered, its pArg value ** is returned. Otherwise NULL is returned. ** ** INVARIANTS: ** ** {F12971} The [sqlite3_update_hook(D,F,P)] interface causes callback ** function F to be invoked with first parameter P whenever ** a table row is modified, inserted, or deleted on ** [database connection] D. ** ** {F12973} The [sqlite3_update_hook(D,F,P)] interface returns the value ** of P for the previous call on the same [database connection] D, ** or NULL for the first call. ** ** {F12975} If the update hook callback F in [sqlite3_update_hook(D,F,P)] ** is NULL then the no update callbacks are made. ................................................................................ ** ** {F12977} Each call to [sqlite3_update_hook(D,F,P)] overrides prior calls ** to the same interface on the same [database connection] D. ** ** {F12979} The update hook callback is not invoked when internal system ** tables such as sqlite_master and sqlite_sequence are modified. ** ** {F12981} The second parameter to the update callback ** is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], ** depending on the operation that caused the callback to be invoked. ** ** {F12983} The third and fourth arguments to the callback contain pointers ** to zero-terminated UTF-8 strings which are the names of the ** database and table that is being updated. ................................................................................ void *sqlite3_update_hook( sqlite3*, void(*)(void *,int ,char const *,char const *,sqlite3_int64), void* ); /* ** CAPI3REF: Enable Or Disable Shared Pager Cache {F10330} ** ** This routine enables or disables the sharing of the database cache ** and schema data structures between connections to the same database. ** Sharing is enabled if the argument is true and disabled if the argument ** is false. ** ** Cache sharing is enabled and disabled ** for an entire process. {END} This is a change as of SQLite version 3.5.0. ** In prior versions of SQLite, sharing was ** enabled or disabled for each thread separately. ** ** The cache sharing mode set by this interface effects all subsequent ** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. ** Existing database connections continue use the sharing mode ** that was in effect at the time they were opened. ** ** Virtual tables cannot be used with a shared cache. When shared ** cache is enabled, the [sqlite3_create_module()] API used to register ** virtual tables will always return an error. ** ** This routine returns [SQLITE_OK] if shared cache was ** enabled or disabled successfully. An [error code] ** is returned otherwise. ** ** Shared cache is disabled by default. But this might change in ** future releases of SQLite. Applications that care about shared ** cache setting should set it explicitly. ** ** INVARIANTS: ** ** {F10331} A successful invocation of [sqlite3_enable_shared_cache(B)] ** will enable or disable shared cache mode for any subsequently ** created [database connection] in the same process. ** ** {F10336} When shared cache is enabled, the [sqlite3_create_module()] ** interface will always return an error. ** ................................................................................ ** [SQLITE_OK] if shared cache was enabled or disabled successfully. ** ** {F10339} Shared cache is disabled by default. */ int sqlite3_enable_shared_cache(int); /* ** CAPI3REF: Attempt To Free Heap Memory {F17340} ** ** The sqlite3_release_memory() interface attempts to ** free N bytes of heap memory by deallocating non-essential memory ** allocations held by the database labrary. {END} Memory used ** to cache database pages to improve performance is an example of ** non-essential memory. Sqlite3_release_memory() returns ** the number of bytes actually freed, which might be more or less ** than the amount requested. ** ** INVARIANTS: ** ** {F17341} The [sqlite3_release_memory(N)] interface attempts to ** free N bytes of heap memory by deallocating non-essential ** memory allocations held by the database labrary. ** ** {F16342} The [sqlite3_release_memory(N)] returns the number ** of bytes actually freed, which might be more or less ** than the amount requested. */ int sqlite3_release_memory(int); /* ** CAPI3REF: Impose A Limit On Heap Size {F17350} ** ** The sqlite3_soft_heap_limit() interface ** places a "soft" limit on the amount of heap memory that may be allocated ** by SQLite. If an internal allocation is requested ** that would exceed the soft heap limit, [sqlite3_release_memory()] is ** invoked one or more times to free up some space before the allocation ** is made. ** ** The limit is called "soft", because if ** [sqlite3_release_memory()] cannot ** free sufficient memory to prevent the limit from being exceeded, ** the memory is allocated anyway and the current operation proceeds. ** ** A negative or zero value for N means that there is no soft heap limit and ** [sqlite3_release_memory()] will only be called when memory is exhausted. ** The default value for the soft heap limit is zero. ** ** SQLite makes a best effort to honor the soft heap limit. ** But if the soft heap limit cannot honored, execution will ** continue without error or notification. This is why the limit is ** called a "soft" limit. It is advisory only. ** ** Prior to SQLite version 3.5.0, this routine only constrained the memory ** allocated by a single thread - the same thread in which this routine ** runs. Beginning with SQLite version 3.5.0, the soft heap limit is ** applied to all threads. The value specified for the soft heap limit ** is an upper bound on the total memory allocation for all threads. In ................................................................................ ** ** {F16358} Each call to [sqlite3_soft_heap_limit(N)] overrides the ** values set by all prior calls. */ void sqlite3_soft_heap_limit(int); /* ** CAPI3REF: Extract Metadata About A Column Of A Table {F12850} ** ** This routine ** returns meta-data about a specific column of a specific database ** table accessible using the connection handle passed as the first function ** argument. ** ** The column is identified by the second, third and fourth parameters to ** this function. The second parameter is either the name of the database ** (i.e. "main", "temp" or an attached database) containing the specified ** table or NULL. If it is NULL, then all attached databases are searched ** for the table using the same algorithm as the database engine uses to ** resolve unqualified table references. ** ** The third and fourth parameters to this function are the table and column ** name of the desired column, respectively. Neither of these parameters ** may be NULL. ** ** Meta information is returned by writing to the memory locations passed as ** the 5th and subsequent parameters to this function. Any of these ** arguments may be NULL, in which case the corresponding element of meta ** information is ommitted. ** ** <pre> ** Parameter Output Type Description ** ----------------------------------- ** ** 5th const char* Data type ** 6th const char* Name of the default collation sequence ** 7th int True if the column has a NOT NULL constraint ** 8th int True if the column is part of the PRIMARY KEY ** 9th int True if the column is AUTOINCREMENT ** </pre> ** ** ** The memory pointed to by the character pointers returned for the ** declaration type and collation sequence is valid only until the next ** call to any sqlite API function. ** ** If the specified table is actually a view, then an error is returned. ** ** If the specified column is "rowid", "oid" or "_rowid_" and an ** INTEGER PRIMARY KEY column has been explicitly declared, then the output ** parameters are set for the explicitly declared column. If there is no ** explicitly declared IPK column, then the output parameters are set as ** follows: ** ** <pre> ** data type: "INTEGER" ** collation sequence: "BINARY" ** not null: 0 ** primary key: 1 ** auto increment: 0 ** </pre> ** ** This function may load one or more schemas from database files. If an ** error occurs during this process, or if the requested table or column ** cannot be found, an SQLITE error code is returned and an error message ** left in the database handle (to be retrieved using sqlite3_errmsg()). ** ** This API is only available if the library was compiled with the ** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. */ int sqlite3_table_column_metadata( sqlite3 *db, /* Connection handle */ const char *zDbName, /* Database name or NULL */ const char *zTableName, /* Table name */ const char *zColumnName, /* Column name */ char const **pzDataType, /* OUTPUT: Declared data type */ ................................................................................ int *pPrimaryKey, /* OUTPUT: True if column part of PK */ int *pAutoinc /* OUTPUT: True if column is auto-increment */ ); /* ** CAPI3REF: Load An Extension {F12600} ** ** {F12601} The sqlite3_load_extension() interface ** attempts to load an SQLite extension library contained in the file ** zFile. {F12602} The entry point is zProc. {F12603} zProc may be 0 ** in which case the name of the entry point defaults ** to "sqlite3_extension_init". ** ** {F12604} The sqlite3_load_extension() interface shall ** return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. ** ** {F12605} ** If an error occurs and pzErrMsg is not 0, then the ** sqlite3_load_extension() interface shall attempt to fill *pzErrMsg with ** error message text stored in memory obtained from [sqlite3_malloc()]. ** {END} The calling function should free this memory ** by calling [sqlite3_free()]. ** ** {F12606} ** Extension loading must be enabled using [sqlite3_enable_load_extension()] ** prior to calling this API or an error will be returned. */ int sqlite3_load_extension( sqlite3 *db, /* Load the extension into this database connection */ const char *zFile, /* Name of the shared library containing extension */ const char *zProc, /* Entry point. Derived from zFile if 0 */ char **pzErrMsg /* Put error message here if not 0 */ ); /* ** CAPI3REF: Enable Or Disable Extension Loading {F12620} ** ** So as not to open security holes in older applications that are ** unprepared to deal with extension loading, and as a means of disabling ** extension loading while evaluating user-entered SQL, the following ** API is provided to turn the [sqlite3_load_extension()] mechanism on and ** off. {F12622} It is off by default. {END} See ticket #1863. ** ** {F12621} Call the sqlite3_enable_load_extension() routine ** with onoff==1 to turn extension loading on ** and call it with onoff==0 to turn it back off again. {END} */ int sqlite3_enable_load_extension(sqlite3 *db, int onoff); /* ** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640} ** ** {F12641} This function ** registers an extension entry point that is automatically invoked ** whenever a new database connection is opened using ** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. {END} ** ** This API can be invoked at program startup in order to register ** one or more statically linked extensions that will be available ** to all new database connections. ** ** {F12642} Duplicate extensions are detected so calling this routine multiple ** times with the same extension is harmless. ** ** {F12643} This routine stores a pointer to the extension in an array ** that is obtained from sqlite_malloc(). {END} If you run a memory leak ** checker on your program and it reports a leak because of this ** array, then invoke [sqlite3_reset_auto_extension()] prior ** to shutdown to free the memory. ** ** {F12644} Automatic extensions apply across all threads. {END} ** ** This interface is experimental and is subject to change or ** removal in future releases of SQLite. */ int sqlite3_auto_extension(void *xEntryPoint); /* ** CAPI3REF: Reset Automatic Extension Loading {F12660} ** ** {F12661} This function disables all previously registered ** automatic extensions. {END} This ** routine undoes the effect of all prior [sqlite3_auto_extension()] ** calls. ** ** {F12662} This call disabled automatic extensions in all threads. {END} ** ** This interface is experimental and is subject to change or ** removal in future releases of SQLite. */ void sqlite3_reset_auto_extension(void); /* ****** EXPERIMENTAL - subject to change without notice ************** ** ** The interface to the virtual-table mechanism is currently considered ** to be experimental. The interface might change in incompatible ways. ** If this is a problem for you, do not use the interface at this time. ** ** When the virtual-table mechanism stablizes, we will declare the ** interface fixed, support it indefinitely, and remove this comment. */ /* ** Structures used by the virtual table interface */ typedef struct sqlite3_vtab sqlite3_vtab; ................................................................................ /* ** CAPI3REF: Virtual Table Object {F18000} ** KEYWORDS: sqlite3_module ** ** A module is a class of virtual tables. Each module is defined ** by an instance of the following structure. This structure consists ** mostly of methods for the module. */ struct sqlite3_module { int iVersion; int (*xCreate)(sqlite3*, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char**); int (*xConnect)(sqlite3*, void *pAux, ................................................................................ ** ** The sqlite3_index_info structure and its substructures is used to ** pass information into and receive the reply from the xBestIndex ** method of an sqlite3_module. The fields under **Inputs** are the ** inputs to xBestIndex and are read-only. xBestIndex inserts its ** results into the **Outputs** fields. ** ** The aConstraint[] array records WHERE clause constraints of the ** form: ** ** column OP expr ** ** Where OP is =, <, <=, >, or >=. ** The particular operator is stored ** in aConstraint[].op. The index of the column is stored in ** aConstraint[].iColumn. aConstraint[].usable is TRUE if the ** expr on the right-hand side can be evaluated (and thus the constraint ** is usable) and false if it cannot. ** ** The optimizer automatically inverts terms of the form "expr OP column" ** and makes other simplifications to the WHERE clause in an attempt to ** get as many WHERE clause terms into the form shown above as possible. ................................................................................ ** the correct order to satisfy the ORDER BY clause so that no separate ** sorting step is required. ** ** The estimatedCost value is an estimate of the cost of doing the ** particular lookup. A full scan of a table with N entries should have ** a cost of N. A binary search of a table of N entries should have a ** cost of approximately log(N). */ struct sqlite3_index_info { /* Inputs */ int nConstraint; /* Number of entries in aConstraint */ struct sqlite3_index_constraint { int iColumn; /* Column on left-hand side of constraint */ unsigned char op; /* Constraint operator */ ................................................................................ #define SQLITE_INDEX_CONSTRAINT_LT 16 #define SQLITE_INDEX_CONSTRAINT_GE 32 #define SQLITE_INDEX_CONSTRAINT_MATCH 64 /* ** CAPI3REF: Register A Virtual Table Implementation {F18200} ** ** This routine is used to register a new module name with an SQLite ** connection. Module names must be registered before creating new ** virtual tables on the module, or before using preexisting virtual ** tables of the module. */ int sqlite3_create_module( sqlite3 *db, /* SQLite connection to register module with */ const char *zName, /* Name of the module */ const sqlite3_module *, /* Methods for the module */ void * /* Client data for xCreate/xConnect */ ); /* ** CAPI3REF: Register A Virtual Table Implementation {F18210} ** ** This routine is identical to the sqlite3_create_module() method above, ** except that it allows a destructor function to be specified. It is ** even more experimental than the rest of the virtual tables API. */ int sqlite3_create_module_v2( sqlite3 *db, /* SQLite connection to register module with */ const char *zName, /* Name of the module */ const sqlite3_module *, /* Methods for the module */ ................................................................................ /* ** CAPI3REF: Virtual Table Instance Object {F18010} ** KEYWORDS: sqlite3_vtab ** ** Every module implementation uses a subclass of the following structure ** to describe a particular instance of the module. Each subclass will ** be tailored to the specific needs of the module implementation. The ** purpose of this superclass is to define certain fields that are common ** to all module implementations. ** ** Virtual tables methods can set an error message by assigning a ** string obtained from sqlite3_mprintf() to zErrMsg. The method should ** take care that any prior string is freed by a call to sqlite3_free() ** prior to assigning a new string to zErrMsg. After the error message ** is delivered up to the client application, the string will be automatically ** freed by sqlite3_free() and the zErrMsg field will be zeroed. Note ** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field ** since virtual tables are commonly implemented in loadable extensions which ** do not have access to sqlite3MPrintf() or sqlite3Free(). */ struct sqlite3_vtab { const sqlite3_module *pModule; /* The module for this virtual table */ int nRef; /* Used internally */ char *zErrMsg; /* Error message from sqlite3_mprintf() */ /* Virtual table implementations will typically add additional fields */ }; ................................................................................ ** to describe cursors that point into the virtual table and are used ** to loop through the virtual table. Cursors are created using the ** xOpen method of the module. Each module implementation will define ** the content of a cursor structure to suit its own needs. ** ** This superclass exists in order to define fields of the cursor that ** are common to all implementations. */ struct sqlite3_vtab_cursor { sqlite3_vtab *pVtab; /* Virtual table of this cursor */ /* Virtual table implementations will typically add additional fields */ }; /* ** CAPI3REF: Declare The Schema Of A Virtual Table {F18280} ** ** The xCreate and xConnect methods of a module use the following API ** to declare the format (the names and datatypes of the columns) of ** the virtual tables they implement. */ int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable); /* ** CAPI3REF: Overload A Function For A Virtual Table {F18300} ** ** Virtual tables can provide alternative implementations of functions ................................................................................ ** must exist in order to be overloaded. ** ** This API makes sure a global version of a function with a particular ** name and number of parameters exists. If no such function exists ** before this API is called, a new function is created. The implementation ** of the new function always causes an exception to be thrown. So ** the new function is not good for anything by itself. Its only ** purpose is to be a place-holder function that can be overloaded ** by virtual tables. ** ** This API should be considered part of the virtual table interface, ** which is experimental and subject to change. */ int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); ................................................................................ ** interface fixed, support it indefinitely, and remove this comment. ** ****** EXPERIMENTAL - subject to change without notice ************** */ /* ** CAPI3REF: A Handle To An Open BLOB {F17800} ** ** An instance of this object represents an open BLOB on which ** incremental I/O can be preformed. ** Objects of this type are created by ** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()]. ** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces ** can be used to read or write small subsections of the blob. ** The [sqlite3_blob_bytes()] interface returns the size of the ** blob in bytes. */ typedef struct sqlite3_blob sqlite3_blob; /* ** CAPI3REF: Open A BLOB For Incremental I/O {F17810} ** ** This interfaces opens a handle to the blob located ** in row iRow, column zColumn, table zTable in database zDb; ** in other words, the same blob that would be selected by: ** ** <pre> ** SELECT zColumn FROM zDb.zTable WHERE rowid = iRow; ** </pre> {END} ** ** If the flags parameter is non-zero, the blob is opened for ** read and write access. If it is zero, the blob is opened for read ** access. ** ** Note that the database name is not the filename that contains ** the database but rather the symbolic name of the database that ** is assigned when the database is connected using [ATTACH]. ** For the main database file, the database name is "main". For ** TEMP tables, the database name is "temp". ** ** On success, [SQLITE_OK] is returned and the new ** [sqlite3_blob | blob handle] is written to *ppBlob. ** Otherwise an error code is returned and ** any value written to *ppBlob should not be used by the caller. ** This function sets the database-handle error code and message ** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()]. ** ** INVARIANTS: ** ** {F17813} A successful invocation of the [sqlite3_blob_open(D,B,T,C,R,F,P)] ** interface opens an [sqlite3_blob] object P on the blob ** in column C of table T in database B on [database connection] D. ** ** {F17814} A successful invocation of [sqlite3_blob_open(D,...)] starts ** a new transaction on [database connection] D if that connection ** is not already in a transaction. ** ** {F17816} The [sqlite3_blob_open(D,B,T,C,R,F,P)] interface opens the blob ** for read and write access if and only if the F parameter ** is non-zero. ** ** {F17819} The [sqlite3_blob_open()] interface returns [SQLITE_OK] on ** success and an appropriate [error code] on failure. ** ** {F17821} If an error occurs during evaluation of [sqlite3_blob_open(D,...)] ** then subsequent calls to [sqlite3_errcode(D)], ** [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return ** information approprate for that error. */ int sqlite3_blob_open( sqlite3*, const char *zDb, const char *zTable, const char *zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob ); /* ** CAPI3REF: Close A BLOB Handle {F17830} ** ** Close an open [sqlite3_blob | blob handle]. ** ** Closing a BLOB shall cause the current transaction to commit ** if there are no other BLOBs, no pending prepared statements, and the ** database connection is in autocommit mode. ** If any writes were made to the BLOB, they might be held in cache ** until the close operation if they will fit. {END} ** Closing the BLOB often forces the changes ** out to disk and so if any I/O errors occur, they will likely occur ** at the time when the BLOB is closed. {F17833} Any errors that occur during ** closing are reported as a non-zero return value. ** ** The BLOB is closed unconditionally. Even if this routine returns ** an error code, the BLOB is still closed. ** ** INVARIANTS: ** ** {F17833} The [sqlite3_blob_close(P)] interface closes an ** [sqlite3_blob] object P previously opened using ** [sqlite3_blob_open()]. ** ** {F17836} Closing an [sqlite3_blob] object using ** [sqlite3_blob_close()] shall cause the current transaction to ** commit if there are no other open [sqlite3_blob] objects ** or [prepared statements] on the same [database connection] and ** the [database connection] is in ** [sqlite3_get_autocommit | autocommit mode]. ** ** {F17839} The [sqlite3_blob_close(P)] interfaces closes the ** [sqlite3_blob] object P unconditionally, even if ** [sqlite3_blob_close(P)] returns something other than [SQLITE_OK]. ** */ int sqlite3_blob_close(sqlite3_blob *); /* ** CAPI3REF: Return The Size Of An Open BLOB {F17840} ** ** Return the size in bytes of the blob accessible via the open ** [sqlite3_blob] object in its only argument. ** ** INVARIANTS: ** ** {F17843} The [sqlite3_blob_bytes(P)] interface returns the size ** in bytes of the BLOB that the [sqlite3_blob] object P ** refers to. */ int sqlite3_blob_bytes(sqlite3_blob *); /* ** CAPI3REF: Read Data From A BLOB Incrementally {F17850} ** ** This function is used to read data from an open ** [sqlite3_blob | blob-handle] into a caller supplied buffer. ** N bytes of data are copied into buffer ** Z from the open blob, starting at offset iOffset. ** ** If offset iOffset is less than N bytes from the end of the blob, ** [SQLITE_ERROR] is returned and no data is read. If N or iOffset is ** less than zero [SQLITE_ERROR] is returned and no data is read. ** ** On success, SQLITE_OK is returned. Otherwise, an ** [error code] or an [extended error code] is returned. ** ** INVARIANTS: ** ** {F17853} The [sqlite3_blob_read(P,Z,N,X)] interface reads N bytes ** beginning at offset X from ** the blob that [sqlite3_blob] object P refers to ** and writes those N bytes into buffer Z. ** ** {F17856} In [sqlite3_blob_read(P,Z,N,X)] if the size of the blob ** is less than N+X bytes, then the function returns [SQLITE_ERROR] ** and nothing is read from the blob. ** ** {F17859} In [sqlite3_blob_read(P,Z,N,X)] if X or N is less than zero ** then the function returns [SQLITE_ERROR] ** and nothing is read from the blob. ** ** {F17862} The [sqlite3_blob_read(P,Z,N,X)] interface returns [SQLITE_OK] ** if N bytes where successfully read into buffer Z. ** ** {F17865} If the requested read could not be completed, ** the [sqlite3_blob_read(P,Z,N,X)] interface returns an ** appropriate [error code] or [extended error code]. ** ** {F17868} If an error occurs during evaluation of [sqlite3_blob_read(P,...)] ** then subsequent calls to [sqlite3_errcode(D)], ** [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return ** information approprate for that error, where D is the ** database handle that was used to open blob handle P. */ int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); /* ** CAPI3REF: Write Data Into A BLOB Incrementally {F17870} ** ** This function is used to write data into an open ** [sqlite3_blob | blob-handle] from a user supplied buffer. ** n bytes of data are copied from the buffer ** pointed to by z into the open blob, starting at offset iOffset. ** ** If the [sqlite3_blob | blob-handle] passed as the first argument ** was not opened for writing (the flags parameter to [sqlite3_blob_open()] *** was zero), this function returns [SQLITE_READONLY]. ** ** This function may only modify the contents of the blob; it is ** not possible to increase the size of a blob using this API. ** If offset iOffset is less than n bytes from the end of the blob, ** [SQLITE_ERROR] is returned and no data is written. If n is ** less than zero [SQLITE_ERROR] is returned and no data is written. ** ** On success, SQLITE_OK is returned. Otherwise, an ** [error code] or an [extended error code] is returned. ** ** INVARIANTS: ** ** {F17873} The [sqlite3_blob_write(P,Z,N,X)] interface writes N bytes ** from buffer Z into ** the blob that [sqlite3_blob] object P refers to ** beginning at an offset of X into the blob. ** ** {F17875} The [sqlite3_blob_write(P,Z,N,X)] interface returns ** [SQLITE_READONLY] if the [sqlite3_blob] object P was ** [sqlite3_blob_open | opened] for reading only. ** ** {F17876} In [sqlite3_blob_write(P,Z,N,X)] if the size of the blob ** is less than N+X bytes, then the function returns [SQLITE_ERROR] ** and nothing is written into the blob. ** ** {F17879} In [sqlite3_blob_write(P,Z,N,X)] if X or N is less than zero ** then the function returns [SQLITE_ERROR] ** and nothing is written into the blob. ** ** {F17882} The [sqlite3_blob_write(P,Z,N,X)] interface returns [SQLITE_OK] ** if N bytes where successfully written into blob. ** ** {F17885} If the requested write could not be completed, ** the [sqlite3_blob_write(P,Z,N,X)] interface returns an ** appropriate [error code] or [extended error code]. ** ** {F17888} If an error occurs during evaluation of [sqlite3_blob_write(D,...)] ** then subsequent calls to [sqlite3_errcode(D)], ** [sqlite3_errmsg(D)], and [sqlite3_errmsg16(D)] will return ** information approprate for that error. */ int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); /* ** CAPI3REF: Virtual File System Objects {F11200} ** ** A virtual filesystem (VFS) is an [sqlite3_vfs] object ** that SQLite uses to interact ** with the underlying operating system. Most SQLite builds come with a ** single default VFS that is appropriate for the host computer. ** New VFSes can be registered and existing VFSes can be unregistered. ** The following interfaces are provided. ** ** The sqlite3_vfs_find() interface returns a pointer to ** a VFS given its name. Names are case sensitive. ** Names are zero-terminated UTF-8 strings. ** If there is no match, a NULL ** pointer is returned. If zVfsName is NULL then the default ** VFS is returned. ** ** New VFSes are registered with sqlite3_vfs_register(). ** Each new VFS becomes the default VFS if the makeDflt flag is set. ** The same VFS can be registered multiple times without injury. ** To make an existing VFS into the default VFS, register it again ** with the makeDflt flag set. If two different VFSes with the ** same name are registered, the behavior is undefined. If a ** VFS is registered with a name that is NULL or an empty string, ** then the behavior is undefined. ** ** Unregister a VFS with the sqlite3_vfs_unregister() interface. ** If the default VFS is unregistered, another VFS is chosen as ** the default. The choice for the new VFS is arbitrary. ** ** INVARIANTS: ** ** {F11203} The [sqlite3_vfs_find(N)] interface returns a pointer to the ** registered [sqlite3_vfs] object whose name exactly matches ** the zero-terminated UTF-8 string N, or it returns NULL if ** there is no match. ** ** {F11206} If the N parameter to [sqlite3_vfs_find(N)] is NULL then ** the function returns a pointer to the default [sqlite3_vfs] ** object if there is one, or NULL if there is no default ** [sqlite3_vfs] object. ** ** {F11209} The [sqlite3_vfs_register(P,F)] interface registers the ** well-formed [sqlite3_vfs] object P using the name given ** by the zName field of the object. ** ** {F11212} Using the [sqlite3_vfs_register(P,F)] interface to register ** the same [sqlite3_vfs] object multiple times is a harmless no-op. ** ** {F11215} The [sqlite3_vfs_register(P,F)] interface makes the ** the [sqlite3_vfs] object P the default [sqlite3_vfs] object ** if F is non-zero. ** ** {F11218} The [sqlite3_vfs_unregister(P)] interface unregisters the ** [sqlite3_vfs] object P so that it is no longer returned by ** subsequent calls to [sqlite3_vfs_find()]. */ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); int sqlite3_vfs_unregister(sqlite3_vfs*); /* ** CAPI3REF: Mutexes {F17000} ** ** The SQLite core uses these routines for thread ** synchronization. Though they are intended for internal ** use by SQLite, code that links against SQLite is ** permitted to use any of these routines. ** ** The SQLite source code contains multiple implementations ** of these mutex routines. An appropriate implementation ** is selected automatically at compile-time. The following ** implementations are available in the SQLite core: ** ** <ul> ** <li> SQLITE_MUTEX_OS2 ** <li> SQLITE_MUTEX_PTHREAD ** <li> SQLITE_MUTEX_W32 ** <li> SQLITE_MUTEX_NOOP ** </ul> ** ** The SQLITE_MUTEX_NOOP implementation is a set of routines ** that does no real locking and is appropriate for use in ** a single-threaded application. The SQLITE_MUTEX_OS2, ** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations ** are appropriate for use on os/2, unix, and windows. ** ** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex ** implementation is included with the library. The ** mutex interface routines defined here become external ** references in the SQLite library for which implementations ** must be provided by the application. This facility allows an ** application that links against SQLite to provide its own mutex ** implementation without having to modify the SQLite core. ** ** {F17011} The sqlite3_mutex_alloc() routine allocates a new ** mutex and returns a pointer to it. {F17012} If it returns NULL ** that means that a mutex could not be allocated. {F17013} SQLite ** will unwind its stack and return an error. {F17014} The argument ** to sqlite3_mutex_alloc() is one of these integer constants: ** ................................................................................ ** <li> SQLITE_MUTEX_RECURSIVE ** <li> SQLITE_MUTEX_STATIC_MASTER ** <li> SQLITE_MUTEX_STATIC_MEM ** <li> SQLITE_MUTEX_STATIC_MEM2 ** <li> SQLITE_MUTEX_STATIC_PRNG ** <li> SQLITE_MUTEX_STATIC_LRU ** <li> SQLITE_MUTEX_STATIC_LRU2 ** </ul> {END} ** ** {F17015} The first two constants cause sqlite3_mutex_alloc() to create ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE ** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END} ** The mutex implementation does not need to make a distinction ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does ** not want to. {F17016} But SQLite will only request a recursive mutex in ................................................................................ ** may add additional static mutexes. Static mutexes are for internal ** use by SQLite only. Applications that use SQLite mutexes should ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or ** SQLITE_MUTEX_RECURSIVE. ** ** {F17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() ** returns a different mutex on every call. {F17034} But for the static ** mutex types, the same mutex is returned on every call that has ** the same type number. {END} ** ** {F17019} The sqlite3_mutex_free() routine deallocates a previously ** allocated dynamic mutex. {F17020} SQLite is careful to deallocate every ** dynamic mutex that it allocates. {U17021} The dynamic mutexes must not be in ** use when they are deallocated. {U17022} Attempting to deallocate a static ** mutex results in undefined behavior. {F17023} SQLite never deallocates ** a static mutex. {END} ** ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt ** to enter a mutex. {F17024} If another thread is already within the mutex, ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return ** SQLITE_BUSY. {F17025} The sqlite3_mutex_try() interface returns SQLITE_OK ** upon successful entry. {F17026} Mutexes created using ** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. ** {F17027} In such cases the, ** mutex must be exited an equal number of times before another thread ** can enter. {U17028} If the same thread tries to enter any other ** kind of mutex more than once, the behavior is undefined. ** {F17029} SQLite will never exhibit ** such behavior in its own use of mutexes. {END} ** ** Some systems (ex: windows95) do not the operation implemented by ** sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() will ** always return SQLITE_BUSY. {F17030} The SQLite core only ever uses ** sqlite3_mutex_try() as an optimization so this is acceptable behavior. {END} ** ** {F17031} The sqlite3_mutex_leave() routine exits a mutex that was ** previously entered by the same thread. {U17032} The behavior ** is undefined if the mutex is not currently entered by the ** calling thread or is not currently allocated. {F17033} SQLite will ** never do either. {END} ** ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. */ sqlite3_mutex *sqlite3_mutex_alloc(int); void sqlite3_mutex_free(sqlite3_mutex*); void sqlite3_mutex_enter(sqlite3_mutex*); int sqlite3_mutex_try(sqlite3_mutex*); void sqlite3_mutex_leave(sqlite3_mutex*); /* ** CAPI3REF: Mutex Verifcation Routines {F17080} ** ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines ** are intended for use inside assert() statements. {F17081} The SQLite core ** never uses these routines except inside an assert() and applications ** are advised to follow the lead of the core. {F17082} The core only ** provides implementations for these routines when it is compiled ** with the SQLITE_DEBUG flag. {U17087} External mutex implementations ** are only required to provide these routines if SQLITE_DEBUG is ** defined and if NDEBUG is not defined. ** ** {F17083} These routines should return true if the mutex in their argument ** is held or not held, respectively, by the calling thread. {END} ** ** {X17084} The implementation is not required to provided versions of these ** routines that actually work. ** If the implementation does not provide working ** versions of these routines, it should at least provide stubs ** that always return true so that one does not get spurious ** assertion failures. {END} ** ** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then ** the routine should return 1. {END} This seems counter-intuitive since ** clearly the mutex cannot be held if it does not exist. But the ** the reason the mutex does not exist is because the build is not ** using mutexes. And we do not want the assert() containing the ** call to sqlite3_mutex_held() to fail, so a non-zero return is ** the appropriate thing to do. {F17086} The sqlite3_mutex_notheld() ** interface should also return 1 when given a NULL pointer. */ int sqlite3_mutex_held(sqlite3_mutex*); int sqlite3_mutex_notheld(sqlite3_mutex*); /* ** CAPI3REF: Mutex Types {F17001} ** ** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument ** which is one of these integer constants. {END} */ #define SQLITE_MUTEX_FAST 0 #define SQLITE_MUTEX_RECURSIVE 1 #define SQLITE_MUTEX_STATIC_MASTER 2 #define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ #define SQLITE_MUTEX_STATIC_MEM2 4 /* sqlite3_release_memory() */ #define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ ................................................................................ ** are passed directly through to the second and third parameters of ** the xFileControl method. {F11305} The return value of the xFileControl ** method becomes the return value of this routine. ** ** {F11306} If the second parameter (zDbName) does not match the name of any ** open database file, then SQLITE_ERROR is returned. {F11307} This error ** code is not remembered and will not be recalled by [sqlite3_errcode()] ** or [sqlite3_errmsg()]. {U11308} The underlying xFileControl method might ** also return SQLITE_ERROR. {U11309} There is no way to distinguish between ** an incorrect zDbName and an SQLITE_ERROR return from the underlying ** xFileControl method. {END} ** ** See also: [SQLITE_FCNTL_LOCKSTATE] */ int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); /* ** CAPI3REF: Testing Interface {F11400} ** ** The sqlite3_test_control() interface is used to read out internal ** state of SQLite and to inject faults into SQLite for testing ** purposes. The first parameter a operation code that determines ** the number, meaning, and operation of all subsequent parameters. ** ** This interface is not for use by applications. It exists solely ** for verifying the correct operation of the SQLite library. Depending ** on how the SQLite library is compiled, this interface might not exist. ** ** The details of the operation codes, their meanings, the parameters ................................................................................ /* ** CAPI3REF: Testing Interface Operation Codes {F11410} ** ** These constants are the valid operation code parameters used ** as the first argument to [sqlite3_test_control()]. ** ** These parameters and their meansing are subject to change ** without notice. These values are for testing purposes only. ** Applications should not use any of these parameters or the ** [sqlite3_test_control()] interface. */ #define SQLITE_TESTCTRL_FAULT_CONFIG 1 #define SQLITE_TESTCTRL_FAULT_FAILURES 2 #define SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES 3 #define SQLITE_TESTCTRL_FAULT_PENDING 4 #define SQLITE_TESTCTRL_PRNG_SAVE 5 #define SQLITE_TESTCTRL_PRNG_RESTORE 6 #define SQLITE_TESTCTRL_PRNG_RESET 7 #define SQLITE_TESTCTRL_BITVEC_TEST 8 /* ** Undo the hack that converts floating point types to integer for ** builds on processors without floating point support. */ #ifdef SQLITE_OMIT_FLOATING_POINT |
| | | < | | | < | | | | | | | | | | | | | | | | | | | | | > > > > > > > > > | | | > > > > > > > > | | | | | | | < | | | | | | | | | < | | > | > < | > > > > > > > > < < < > > < > > > > | < > | < > > > | < > > > | < < < < < > > > | | | | < | | | > > > > > > > > > > | < | > | | | | > > > | | | | | | < < | | | | | < | > | | > < | | < < > > | < > | | | > | | | | | | > > > | | | | | | | | | | | | | | | | | | | | | | | > > > | | < | | > | > | | | < | | | < | | | | < | | | | | | | | | | | > > > | > | | | > | > | > > > > | < | | | | | | | | < | | | > | | | | | | | < | | | | | | | | | < | | | | | < | < > | | | | | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | < | | < | | < | | | | | | | | < | | | | | | | | < | | | | | | | < | | | | | | < | | > | | | > > > > > | | | | | | | | < < | | | | < | < > > | | | | > > > | | | | | | | | > | | | | > | < | | | | | > | | < > > > > | | | | | > | < | < | > | | | | | < | | | < | | | | | | | | | < > | | > | | | < | | | | | | | | | | | | | | | | | | | | | < | | | | < | | | | | | < | | | | > | | < | > | | < > | | | > > > > > > > > > > | | | | | | | | | | | | < | | | | < | | | < | | < | < | | | | | < | | | | | | | | > | | | | | < | | | < | | | | | | | | | | < | | | | | < | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | > | | | | < | | | | < | > | < < | | | | | < | < > | | | < > | | < > > | | > > > | < | > > < < | | < < < < | | > | > | > > > > > > > > > | | | | < | | | | | | | < | | < > | | | < | | > > > > > | < | | | | | | > > > > | < | < | | | | | | | | | | | < | | < | | | | | | < > | < > | < > | | | | < | | | | | | | | | | | < | | < | | | < | | < | | | | | | < | | | | | | | | > | < | | < | | < | | < | | < | | | | > > | | | | | < | | > | | | > | > > > > | > > | | < | | < | | | > | | | | | | | < | | | | | | | | | | | | < | | | | | | | | | | | > | | | | | | | | | | | | | < | | > | | | | | < | | | < | | | < | | < | | | | | < | | | < | | < | | < > | | | | | | | | | < | | | | | | < | | | | | | | | < | | < < > | | < | | | | | < | | < < > | | < | | | | | < | | < | | | | | < | | | | | | | | > | | | | < | | | | < | | | | | | | | < | | | | < | | | | | < | | | | < | < | | | | | | | | > | | < | | | < | | | | | | | < | | | < < > | | | | > | < | | < | | | < | | | | | | | | < | | | | | | | | | | | < | | | < | | | | | | | | | | | | > | | | | | | | | | | | | | | | < | | | < | | | | | < | | | | | > > | | | | | | | < | > | < | | | | | | < | | < | | | | | | < | | | < | | | | < | | | | | | | | | | < | | | | | | | > | | | < | | | | | | < | | < | | < | | < | | | | | < | | | | | | | | | | | < | | < | | | < | < < < > | | > | | | | | | | | > | < | | | | | | | < | | | | | | | | | | | | | | | | | | | | | | | | | | < | | < | | | | | | | | | | | | | | | | | < | < < | < | | | | | | | | | | > | | | | | | | < | | | | < | < | | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | | | < < | | | | < | | | | | | | | | | | | | | | < | | < > | | | < | < | | | | > | | < > | | < | | | | < | | | | | | < | | | | | | | | | < | < | | | | | < | > | < | | | | | | | < | > | < > | < | | < > | > < | | | | | | > | < | | | > > | | > | > | | | | < | < > | | | < | > | | | | | > | | | > > < < < < < | > > > > > > > > > > | | < < < < > | < < < < | | | < > | | < < | > > > | < | | < | > > > | | | | > > > | | | | | | > > > > > > > > > | > < > | | | | < | | | | < | | | | < | | | > > > > > > > > > > > | | > | | | | | | | | | > > > > > | | | > | | < | < | < | | | | | < | | | | > > > | | | | | | | | | | | | | > > > > | | | | | | < | | | | | | | | | > > > > > > > | | | > > | < < > > > > > | < < > > | < < > > > > > | < > | | | | | | | | | | | < | | | | < | | | | | | | | | | | < | | | | | | | | | | | | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | | < | | | < | | | | | | < < < < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > |
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 .. 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 .. 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 ... 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 ... 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 ... 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 ... 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 ... 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 ... 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 ... 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 .... 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 .... 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 .... 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 .... 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 .... 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 .... 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 .... 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 .... 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 .... 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 .... 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 .... 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 .... 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 .... 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 .... 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 .... 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 .... 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 .... 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 .... 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 .... 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 .... 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 .... 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 .... 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 .... 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 .... 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 .... 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 .... 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 .... 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 .... 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 .... 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 .... 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 .... 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 .... 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 .... 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 .... 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 .... 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 .... 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 .... 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 .... 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 .... 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 .... 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 .... 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 .... 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 .... 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 .... 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 .... 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 .... 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 .... 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 .... 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 .... 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 .... 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 .... 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 .... 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 .... 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 .... 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 .... 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 .... 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 .... 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 .... 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 .... 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 .... 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 .... 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 .... 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 .... 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 .... 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 .... 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 .... 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 .... 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 .... 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 .... 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 |
** presents to client programs. If a C-function, structure, datatype, ** or constant definition does not appear in this file, then it is ** not a published API of SQLite, is subject to change without ** notice, and should not be referenced by programs that use SQLite. ** ** Some of the definitions that are in this file are marked as ** "experimental". Experimental interfaces are normally new ** features recently added to SQLite. We do not anticipate changes ** to experimental interfaces but reserve to make minor changes if ** experience from use "in the wild" suggest such changes are prudent. ** ** The official C-language API documentation for SQLite is derived ** from comments in this file. This file is the authoritative source ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** ** @(#) $Id: sqlite3.h,v 1.35 2008/07/16 23:42:29 rmsimpson Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. ................................................................................ ** Add the ability to override 'extern' */ #ifndef SQLITE_EXTERN # define SQLITE_EXTERN extern #endif /* ** Ensure these symbols were not defined by some previous header file. */ #ifdef SQLITE_VERSION # undef SQLITE_VERSION #endif #ifdef SQLITE_VERSION_NUMBER # undef SQLITE_VERSION_NUMBER #endif ................................................................................ ** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in ** the sqlite3.h file specify the version of SQLite with which ** that header file is associated. ** ** The "version" of SQLite is a string of the form "X.Y.Z". ** The phrase "alpha" or "beta" might be appended after the Z. ** The X value is major version number always 3 in SQLite3. ** The X value only changes when backwards compatibility is ** broken and we intend to never break backwards compatibility. ** The Y value is the minor version number and only changes when ** there are major feature enhancements that are forwards compatible ** but not backwards compatible. ** The Z value is the release number and is incremented with ** each release but resets back to 0 whenever Y is incremented. ** ** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. ** ** INVARIANTS: ** ** {F10011} The SQLITE_VERSION #define in the sqlite3.h header file shall ** evaluate to a string literal that is the SQLite version ** with which the header file is associated. ** ** {F10014} The SQLITE_VERSION_NUMBER #define shall resolve to an integer ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z ** are the major version, minor version, and release number. */ #define SQLITE_VERSION "3.6.0" #define SQLITE_VERSION_NUMBER 3006000 /* ** CAPI3REF: Run-Time Library Version Numbers {F10020} ** KEYWORDS: sqlite3_version ** ** These features provide the same information as the [SQLITE_VERSION] ** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated ** with the library instead of the header file. Cautious programmers might ** include a check in their application to verify that ** sqlite3_libversion_number() always returns the value ** [SQLITE_VERSION_NUMBER]. ** ** The sqlite3_libversion() function returns the same information as is ** in the sqlite3_version[] string constant. The function is provided ** for use in DLLs since DLL users usually do not have direct access to string ** constants within the DLL. ** ** INVARIANTS: ** ** {F10021} The [sqlite3_libversion_number()] interface shall return ** an integer equal to [SQLITE_VERSION_NUMBER]. ** ** {F10022} The [sqlite3_version] string constant shall contain ** the text of the [SQLITE_VERSION] string. ** ** {F10023} The [sqlite3_libversion()] function shall return ** a pointer to the [sqlite3_version] string constant. */ SQLITE_EXTERN const char sqlite3_version[]; const char *sqlite3_libversion(void); int sqlite3_libversion_number(void); /* ** CAPI3REF: Test To See If The Library Is Threadsafe {F10100} ** ** SQLite can be compiled with or without mutexes. When ** the [SQLITE_THREADSAFE] C preprocessor macro is true, mutexes ** are enabled and SQLite is threadsafe. When that macro is false, ** the mutexes are omitted. Without the mutexes, it is not safe ** to use SQLite concurrently from more than one thread. ** ** Enabling mutexes incurs a measurable performance penalty. ** So if speed is of utmost importance, it makes sense to disable ** the mutexes. But for maximum safety, mutexes should be enabled. ** The default behavior is for mutexes to be enabled. ** ** This interface can be used by a program to make sure that the ** version of SQLite that it is linking against was compiled with ** the desired setting of the [SQLITE_THREADSAFE] macro. ** ** This interface only reports on the compile-time mutex setting ** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with ** SQLITE_THREADSAFE=1 then mutexes are enabled by default but ** can be fully or partially disabled using a call to [sqlite3_config()] ** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], ** or [SQLITE_CONFIG_MUTEX]. The return value of this function shows ** only the default compile-time setting, not any run-time changes ** to that setting. ** ** INVARIANTS: ** ** {F10101} The [sqlite3_threadsafe()] function shall return nonzero if ** SQLite was compiled with the its mutexes enabled by default ** or zero if SQLite was compiled such that mutexes are ** permanently disabled. ** ** {F10102} The value returned by the [sqlite3_threadsafe()] function ** shall not change when mutex setting are modified at ** runtime using the [sqlite3_config()] interface and ** especially the [SQLITE_CONFIG_SINGLETHREAD], ** [SQLITE_CONFIG_MULTITHREAD], [SQLITE_CONFIG_SERIALIZED], ** and [SQLITE_CONFIG_MUTEX] verbs. */ int sqlite3_threadsafe(void); /* ** CAPI3REF: Database Connection Handle {F12000} ** KEYWORDS: {database connection} {database connections} ** ** Each open SQLite database is represented by a pointer to an instance of ** the opaque structure named "sqlite3". It is useful to think of an sqlite3 ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] ** is its destructor. There are many other interfaces (such as ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and ** [sqlite3_busy_timeout()] to name but three) that are methods on an ** sqlite3 object. */ typedef struct sqlite3 sqlite3; /* ** CAPI3REF: 64-Bit Integer Types {F10200} ** KEYWORDS: sqlite_int64 sqlite_uint64 ** ** Because there is no cross-platform way to specify 64-bit integer types ** SQLite includes typedefs for 64-bit signed and unsigned integers. ** ** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. ** The sqlite_int64 and sqlite_uint64 types are supported for backwards ** compatibility only. ** ** INVARIANTS: ** ** {F10201} The [sqlite_int64] and [sqlite3_int64] type shall specify ** a 64-bit signed integer. ** ** {F10202} The [sqlite_uint64] and [sqlite3_uint64] type shall specify ** a 64-bit unsigned integer. */ #ifdef SQLITE_INT64_TYPE typedef SQLITE_INT64_TYPE sqlite_int64; typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; #elif defined(_MSC_VER) || defined(__BORLANDC__) typedef __int64 sqlite_int64; ................................................................................ typedef unsigned long long int sqlite_uint64; #endif typedef sqlite_int64 sqlite3_int64; typedef sqlite_uint64 sqlite3_uint64; /* ** If compiling for a processor that lacks floating point support, ** substitute integer for floating-point. */ #ifdef SQLITE_OMIT_FLOATING_POINT # define double sqlite3_int64 #endif /* ** CAPI3REF: Closing A Database Connection {F12010} ** ** This routine is the destructor for the [sqlite3] object. ** ** Applications should [sqlite3_finalize | finalize] all [prepared statements] ** and [sqlite3_blob_close | close] all [BLOB handles] associated with ** the [sqlite3] object prior to attempting to close the object. ** The [sqlite3_next_stmt()] interface can be used to locate all ** [prepared statements] associated with a [database connection] if desired. ** Typical code might look like this: ** ** <blockquote><pre> ** sqlite3_stmt *pStmt; ** while( (pStmt = sqlite3_next_stmt(db, 0))!=0 ){ ** sqlite3_finalize(pStmt); ** } ** </pre></blockquote> ** ** If [sqlite3_close()] is invoked while a transaction is open, ** the transaction is automatically rolled back. ** ** INVARIANTS: ** ** {F12011} A successful call to [sqlite3_close(C)] shall destroy the ** [database connection] object C. ** ** {F12012} A successful call to [sqlite3_close(C)] shall return SQLITE_OK. ** ** {F12013} A successful call to [sqlite3_close(C)] shall release all ** memory and system resources associated with [database connection] ** C. ** ** {F12014} A call to [sqlite3_close(C)] on a [database connection] C that ** has one or more open [prepared statements] shall fail with ** an [SQLITE_BUSY] error code. ** ** {F12015} A call to [sqlite3_close(C)] where C is a NULL pointer shall ** return SQLITE_OK. ** ** {F12019} When [sqlite3_close(C)] is invoked on a [database connection] C ** that has a pending transaction, the transaction shall be ** rolled back. ** ** LIMITATIONS: ** ** {A12016} The C parameter to [sqlite3_close(C)] must be either a NULL ** pointer or an [sqlite3] object pointer previously obtained ** from [sqlite3_open()], [sqlite3_open16()], or ** [sqlite3_open_v2()], and not previously closed. */ int sqlite3_close(sqlite3 *); /* ** The type for a callback function. ** This is legacy and deprecated. It is included for historical ** compatibility and is not documented. */ typedef int (*sqlite3_callback)(void*,int,char**, char**); /* ** CAPI3REF: One-Step Query Execution Interface {F12100} ** ** The sqlite3_exec() interface is a convenient way of running one or more ** SQL statements without having to write a lot of C code. The UTF-8 encoded ** SQL statements are passed in as the second parameter to sqlite3_exec(). ** The statements are evaluated one by one until either an error or ** an interrupt is encountered, or until they are all done. The 3rd parameter ** is an optional callback that is invoked once for each row of any query ** results produced by the SQL statements. The 5th parameter tells where ** to write any error messages. ** ** The error message passed back through the 5th parameter is held ** in memory obtained from [sqlite3_malloc()]. To avoid a memory leak, ** the calling application should call [sqlite3_free()] on any error ** message returned through the 5th parameter when it has finished using ** the error message. ** ** If the SQL statement in the 2nd parameter is NULL or an empty string ** or a string containing only whitespace and comments, then no SQL ** statements are evaluated and the database is not changed. ** ** The sqlite3_exec() interface is implemented in terms of ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()]. ** The sqlite3_exec() routine does nothing to the database that cannot be done ** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()]. ** ** INVARIANTS: ** ** {F12101} A successful invocation of [sqlite3_exec(D,S,C,A,E)] ** shall sequentially evaluate all of the UTF-8 encoded, ** semicolon-separated SQL statements in the zero-terminated ** string S within the context of the [database connection] D. ** ** {F12102} If the S parameter to [sqlite3_exec(D,S,C,A,E)] is NULL then ** the actions of the interface shall be the same as if the ** S parameter were an empty string. ** ** {F12104} The return value of [sqlite3_exec()] shall be [SQLITE_OK] if all ** SQL statements run successfully and to completion. ** ** {F12105} The return value of [sqlite3_exec()] shall be an appropriate ** non-zero [error code] if any SQL statement fails. ** ** {F12107} If one or more of the SQL statements handed to [sqlite3_exec()] ** return results and the 3rd parameter is not NULL, then ** the callback function specified by the 3rd parameter shall be ** invoked once for each row of result. ** ** {F12110} If the callback returns a non-zero value then [sqlite3_exec()] ** shall abort the SQL statement it is currently evaluating, ** skip all subsequent SQL statements, and return [SQLITE_ABORT]. ** ** {F12113} The [sqlite3_exec()] routine shall pass its 4th parameter through ** as the 1st parameter of the callback. ** ** {F12116} The [sqlite3_exec()] routine shall set the 2nd parameter of its ** callback to be the number of columns in the current row of ** result. ** ** {F12119} The [sqlite3_exec()] routine shall set the 3rd parameter of its ** callback to be an array of pointers to strings holding the ** values for each column in the current result set row as ** obtained from [sqlite3_column_text()]. ** ** {F12122} The [sqlite3_exec()] routine shall set the 4th parameter of its ** callback to be an array of pointers to strings holding the ** names of result columns as obtained from [sqlite3_column_name()]. ** ** {F12125} If the 3rd parameter to [sqlite3_exec()] is NULL then ** [sqlite3_exec()] shall silently discard query results. ** ** {F12131} If an error occurs while parsing or evaluating any of the SQL ** statements in the S parameter of [sqlite3_exec(D,S,C,A,E)] and if ** the E parameter is not NULL, then [sqlite3_exec()] shall store ** in *E an appropriate error message written into memory obtained ** from [sqlite3_malloc()]. ** ** {F12134} The [sqlite3_exec(D,S,C,A,E)] routine shall set the value of ** *E to NULL if E is not NULL and there are no errors. ** ** {F12137} The [sqlite3_exec(D,S,C,A,E)] function shall set the [error code] ** and message accessible via [sqlite3_errcode()], ** [sqlite3_errmsg()], and [sqlite3_errmsg16()]. ** ** {F12138} If the S parameter to [sqlite3_exec(D,S,C,A,E)] is NULL or an ** empty string or contains nothing other than whitespace, comments, ** and/or semicolons, then results of [sqlite3_errcode()], ** [sqlite3_errmsg()], and [sqlite3_errmsg16()] ** shall reset to indicate no errors. ** ** LIMITATIONS: ** ** {A12141} The first parameter to [sqlite3_exec()] must be an valid and open ** [database connection]. ** ** {A12142} The database connection must not be closed while ** [sqlite3_exec()] is running. ** ** {A12143} The calling function should use [sqlite3_free()] to free ** the memory that *errmsg is left pointing at once the error ** message is no longer needed. ** ** {A12145} The SQL statement text in the 2nd parameter to [sqlite3_exec()] ** must remain unchanged while [sqlite3_exec()] is running. */ int sqlite3_exec( sqlite3*, /* An open database */ const char *sql, /* SQL to be evaluated */ int (*callback)(void*,int,char**,char**), /* Callback function */ void *, /* 1st argument to callback */ char **errmsg /* Error msg written here */ ); /* ** CAPI3REF: Result Codes {F10210} ** KEYWORDS: SQLITE_OK {error code} {error codes} ** KEYWORDS: {result code} {result codes} ** ** Many SQLite functions return an integer result code from the set shown ** here in order to indicates success or failure. ** ** New error codes may be added in future versions of SQLite. ** ** See also: [SQLITE_IOERR_READ | extended result codes] */ #define SQLITE_OK 0 /* Successful result */ /* beginning-of-error-codes */ #define SQLITE_ERROR 1 /* SQL error or missing database */ #define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ ................................................................................ #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* end-of-error-codes */ /* ** CAPI3REF: Extended Result Codes {F10220} ** KEYWORDS: {extended error code} {extended error codes} ** KEYWORDS: {extended result code} {extended result codes} ** ** In its default configuration, SQLite API routines return one of 26 integer ** [SQLITE_OK | result codes]. However, experience has shown that many of ** these result codes are too coarse-grained. They do not provide as ** much information about problems as programmers might like. In an effort to ** address this, newer versions of SQLite (version 3.3.8 and later) include ** support for additional result codes that provide more detailed information ** about errors. The extended result codes are enabled or disabled ** on a per database connection basis using the ** [sqlite3_extended_result_codes()] API. ** ** Some of the available extended result codes are listed here. ** One may expect the number of extended result codes will be expand ** over time. Software that uses extended result codes should expect ** to see new result codes in future releases of SQLite. ** ** The SQLITE_OK result code will never be extended. It will always ** be exactly zero. ** ** INVARIANTS: ** ** {F10223} The symbolic name for an extended result code shall contains ** a related primary result code as a prefix. ** ** {F10224} Primary result code names shall contain a single "_" character. ** ** {F10225} Extended result code names shall contain two or more "_" characters. ** ** {F10226} The numeric value of an extended result code shall contain the ** numeric value of its corresponding primary result code in ** its least significant 8 bits. */ #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) #define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) /* ** CAPI3REF: Flags For File Open Operations {F10230} ** ** These bit values are intended for use in the ** 3rd parameter to the [sqlite3_open_v2()] interface and ** in the 4th parameter to the xOpen method of the ................................................................................ #define SQLITE_OPEN_MAIN_DB 0x00000100 #define SQLITE_OPEN_TEMP_DB 0x00000200 #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 #define SQLITE_OPEN_SUBJOURNAL 0x00002000 #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 #define SQLITE_OPEN_NOMUTEX 0x00008000 /* ** CAPI3REF: Device Characteristics {F10240} ** ** The xDeviceCapabilities method of the [sqlite3_io_methods] ** object returns an integer which is a vector of the these ** bit values expressing I/O characteristics of the mass storage ................................................................................ ** ** When SQLite invokes the xSync() method of an ** [sqlite3_io_methods] object it uses a combination of ** these integer values as the second argument. ** ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the ** sync operation only needs to flush data to mass storage. Inode ** information need not be flushed. The SQLITE_SYNC_NORMAL flag means ** to use normal fsync() semantics. The SQLITE_SYNC_FULL flag means ** to use Mac OS-X style fullsync instead of fsync(). */ #define SQLITE_SYNC_NORMAL 0x00002 #define SQLITE_SYNC_FULL 0x00003 #define SQLITE_SYNC_DATAONLY 0x00010 /* ** CAPI3REF: OS Interface Open File Handle {F11110} ** ** An [sqlite3_file] object represents an open file in the OS ** interface layer. Individual OS interface implementations will ** want to subclass this object by appending additional fields ................................................................................ struct sqlite3_file { const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ }; /* ** CAPI3REF: OS Interface File Virtual Methods Object {F11120} ** ** Every file opened by the [sqlite3_vfs] xOpen method populates an ** [sqlite3_file] object (or, more commonly, a subclass of the ** [sqlite3_file] object) with a pointer to an instance of this object. ** This object defines the methods used to perform various operations ** against the open file represented by the [sqlite3_file] object. ** ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or ** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). ** The second choice is a Mac OS-X style fullsync. The [SQLITE_SYNC_DATAONLY] ** flag may be ORed in to indicate that only the data of the file ** and not its inode needs to be synced. ** ** The integer values to xLock() and xUnlock() are one of ** <ul> ** <li> [SQLITE_LOCK_NONE], ** <li> [SQLITE_LOCK_SHARED], ** <li> [SQLITE_LOCK_RESERVED], ** <li> [SQLITE_LOCK_PENDING], or ** <li> [SQLITE_LOCK_EXCLUSIVE]. ** </ul> ** xLock() increases the lock. xUnlock() decreases the lock. ** The xCheckReservedLock() method checks whether any database connection, ** either in this process or in some other process, is holding a RESERVED, ** PENDING, or EXCLUSIVE lock on the file. It returns true ** if such a lock exists and false otherwise. ** ** The xFileControl() method is a generic interface that allows custom ** VFS implementations to directly control an open file using the ** [sqlite3_file_control()] interface. The second "op" argument is an ** integer opcode. The third argument is a generic pointer intended to ** point to a structure that may contain arguments or space in which to ** write return values. Potential uses for xFileControl() might be ** functions to enable blocking locks with timeouts, to change the ** locking strategy (for example to use dot-file locks), to inquire ** about the status of a lock, or to break stale locks. The SQLite ** core reserves all opcodes less than 100 for its own use. ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. ** Applications that define a custom xFileControl method should use opcodes ** greater than 100 to avoid conflicts. ** ** The xSectorSize() method returns the sector size of the ** device that underlies the file. The sector size is the ** minimum write that can be performed without disturbing ** other bytes in the file. The xDeviceCharacteristics() ** method returns a bit vector describing behaviors of the ................................................................................ int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); int (*xSync)(sqlite3_file*, int flags); int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); int (*xLock)(sqlite3_file*, int); int (*xUnlock)(sqlite3_file*, int); int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); int (*xFileControl)(sqlite3_file*, int op, void *pArg); int (*xSectorSize)(sqlite3_file*); int (*xDeviceCharacteristics)(sqlite3_file*); /* Additional methods may be added in future releases */ }; /* ** CAPI3REF: Standard File Control Opcodes {F11310} ** ** These integer constants are opcodes for the xFileControl method ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] ** interface. ** ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ** opcode causes the xFileControl method to write the current state of ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ** into an integer that the pArg argument points to. This capability ................................................................................ ** Mutexes are created using [sqlite3_mutex_alloc()]. */ typedef struct sqlite3_mutex sqlite3_mutex; /* ** CAPI3REF: OS Interface Object {F11140} ** ** An instance of the sqlite3_vfs object defines the interface between ** the SQLite core and the underlying operating system. The "vfs" ** in the name of the object stands for "virtual file system". ** ** The value of the iVersion field is initially 1 but may be larger in ** future versions of SQLite. Additional fields may be appended to this ** object when the iVersion value is increased. Note that the structure ** of the sqlite3_vfs object changes in the transaction between ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not ** modified. ** ** The szOsFile field is the size of the subclassed [sqlite3_file] ** structure used by this VFS. mxPathname is the maximum length of ** a pathname in this VFS. ** ** Registered sqlite3_vfs objects are kept on a linked list formed by ** the pNext pointer. The [sqlite3_vfs_register()] ** and [sqlite3_vfs_unregister()] interfaces manage this list ** in a thread-safe way. The [sqlite3_vfs_find()] interface ** searches the list. Neither the application code nor the VFS ** implementation should use the pNext pointer. ** ** The pNext field is the only field in the sqlite3_vfs ** structure that SQLite will ever modify. SQLite will only access ** or modify this field while holding a particular static mutex. ** The application should never modify anything within the sqlite3_vfs ** object once the object has been registered. ** ** The zName field holds the name of the VFS module. The name must ** be unique across all VFS modules. ** ** {F11141} SQLite will guarantee that the zFilename parameter to xOpen ** is either a NULL pointer or string obtained ** from xFullPathname(). SQLite further guarantees that ** the string will be valid and unchanged until xClose() is ** called. {END} Becasue of the previous sentense, ** the [sqlite3_file] can safely store a pointer to the ** filename if it needs to remember the filename for some reason. ** If the zFilename parameter is xOpen is a NULL pointer then xOpen ** must invite its own temporary name for the file. Whenever the ** xFilename parameter is NULL it will also be the case that the ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. ** ** {F11142} The flags argument to xOpen() includes all bits set in ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] ** or [sqlite3_open16()] is used, then flags includes at least ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END} ** If xOpen() opens a file read-only then it sets *pOutFlags to ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. ** ** {F11143} SQLite will also add one of the following flags to the xOpen() ** call, depending on the object being opened: ** ** <ul> ** <li> [SQLITE_OPEN_MAIN_DB] ** <li> [SQLITE_OPEN_MAIN_JOURNAL] ** <li> [SQLITE_OPEN_TEMP_DB] ** <li> [SQLITE_OPEN_TEMP_JOURNAL] ** <li> [SQLITE_OPEN_TRANSIENT_DB] ** <li> [SQLITE_OPEN_SUBJOURNAL] ** <li> [SQLITE_OPEN_MASTER_JOURNAL] ** </ul> {END} ** ** The file I/O implementation can use the object type flags to ** change the way it deals with files. For example, an application ** that does not care about crash recovery or rollback might make ** the open of a journal file a no-op. Writes to this journal would ** also be no-ops, and any attempt to read the journal would return ** SQLITE_IOERR. Or the implementation might recognize that a database ** file will be doing page-aligned sector reads and writes in a random ** order and set up its I/O subsystem accordingly. ** ** SQLite might also add one of the following flags to the xOpen method: ** ** <ul> ** <li> [SQLITE_OPEN_DELETEONCLOSE] ** <li> [SQLITE_OPEN_EXCLUSIVE] ** </ul> ** ** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be ** deleted when it is closed. {F11146} The [SQLITE_OPEN_DELETEONCLOSE] ** will be set for TEMP databases, journals and for subjournals. ** ** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened ** for exclusive access. This flag is set for all files except ** for the main database file. ** ** {F11148} At least szOsFile bytes of memory are allocated by SQLite ** to hold the [sqlite3_file] structure passed as the third ** argument to xOpen. {END} The xOpen method does not have to ** allocate the structure; it should just fill it in. ** ** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] ** to test whether a file is at least readable. {END} The file can be a ** directory. ** ** {F11150} SQLite will always allocate at least mxPathname+1 bytes for the ** output buffer xFullPathname. {F11151} The exact size of the output buffer ** is also passed as a parameter to both methods. {END} If the output buffer ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is ** handled as a fatal error by SQLite, vfs implementations should endeavor ** to prevent this by setting mxPathname to a sufficiently large value. ** ** The xRandomness(), xSleep(), and xCurrentTime() interfaces ** are not strictly a part of the filesystem, but they are ** included in the VFS structure for completeness. ** The xRandomness() function attempts to return nBytes bytes ** of good-quality randomness into zOut. The return value is ** the actual number of bytes of randomness obtained. ** The xSleep() method causes the calling thread to sleep for at ** least the number of microseconds given. The xCurrentTime() ** method returns a Julian Day Number for the current date and time. */ typedef struct sqlite3_vfs sqlite3_vfs; struct sqlite3_vfs { int iVersion; /* Structure version number */ int szOsFile; /* Size of subclassed sqlite3_file */ int mxPathname; /* Maximum file pathname length */ sqlite3_vfs *pNext; /* Next registered VFS */ const char *zName; /* Name of this virtual file system */ void *pAppData; /* Pointer to application-specific data */ int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, int flags, int *pOutFlags); int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol); void (*xDlClose)(sqlite3_vfs*, void*); int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); int (*xSleep)(sqlite3_vfs*, int microseconds); int (*xCurrentTime)(sqlite3_vfs*, double*); int (*xGetLastError)(sqlite3_vfs*, int, char *); /* New fields may be appended in figure versions. The iVersion ** value will increment whenever this happens. */ }; /* ** CAPI3REF: Flags for the xAccess VFS method {F11190} ** ** {F11191} These integer constants can be used as the third parameter to ** the xAccess method of an [sqlite3_vfs] object. {END} They determine ** what kind of permissions the xAccess method is looking for. ** {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method ** simply checks whether the file exists. ** {F11193} With SQLITE_ACCESS_READWRITE, the xAccess method ** checks whether the file is both readable and writable. ** {F11194} With SQLITE_ACCESS_READ, the xAccess method ** checks whether the file is readable. */ #define SQLITE_ACCESS_EXISTS 0 #define SQLITE_ACCESS_READWRITE 1 #define SQLITE_ACCESS_READ 2 /* ** CAPI3REF: Initialize The SQLite Library {F10130} ** ** The sqlite3_initialize() routine initializes the ** SQLite library. The sqlite3_shutdown() routine ** deallocates any resources that were allocated by sqlite3_initialize(). ** ** A call to sqlite3_initialize() is an "effective" call if it is ** the first time sqlite3_initialize() is invoked during the lifetime of ** the process, or if it is the first time sqlite3_initialize() is invoked ** following a call to sqlite3_shutdown(). Only an effective call ** of sqlite3_initialize() does any initialization. All other calls ** are harmless no-ops. ** ** Among other things, sqlite3_initialize() shall invoke ** sqlite3_os_init(). Similarly, sqlite3_shutdown() ** shall invoke sqlite3_os_end(). ** ** The sqlite3_initialize() routine returns SQLITE_OK on success. ** If for some reason, sqlite3_initialize() is unable to initialize ** the library (perhaps it is unable to allocate a needed resource such ** as a mutex) it returns an [error code] other than SQLITE_OK. ** ** The sqlite3_initialize() routine is called internally by many other ** SQLite interfaces so that an application usually does not need to ** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] ** calls sqlite3_initialize() so the SQLite library will be automatically ** initialized when [sqlite3_open()] is called if it has not be initialized ** already. However, if SQLite is compiled with the SQLITE_OMIT_AUTOINIT ** compile-time option, then the automatic calls to sqlite3_initialize() ** are omitted and the application must call sqlite3_initialize() directly ** prior to using any other SQLite interface. For maximum portability, ** it is recommended that applications always invoke sqlite3_initialize() ** directly prior to using any other SQLite interface. Future releases ** of SQLite may require this. In other words, the behavior exhibited ** when SQLite is compiled with SQLITE_OMIT_AUTOINIT might become the ** default behavior in some future release of SQLite. ** ** The sqlite3_os_init() routine does operating-system specific ** initialization of the SQLite library. The sqlite3_os_end() ** routine undoes the effect of sqlite3_os_init(). Typical tasks ** performed by these routines include allocation or deallocation ** of static resources, initialization of global variables, ** setting up a default [sqlite3_vfs] module, or setting up ** a default configuration using [sqlite3_config()]. ** ** The application should never invoke either sqlite3_os_init() ** or sqlite3_os_end() directly. The application should only invoke ** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() ** interface is called automatically by sqlite3_initialize() and ** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate ** implementations for sqlite3_os_init() and sqlite3_os_end() ** are built into SQLite when it is compiled for unix, windows, or os/2. ** When built for other platforms (using the SQLITE_OS_OTHER=1 compile-time ** option) the application must supply a suitable implementation for ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied ** implementation of sqlite3_os_init() or sqlite3_os_end() ** must return SQLITE_OK on success and some other [error code] upon ** failure. */ int sqlite3_initialize(void); int sqlite3_shutdown(void); int sqlite3_os_init(void); int sqlite3_os_end(void); /* ** CAPI3REF: Configuring The SQLite Library {F10145} ** ** The sqlite3_config() interface is used to make global configuration ** changes to SQLite in order to tune SQLite to the specific needs of ** the application. The default configuration is recommended for most ** applications and so this routine is usually not necessary. It is ** provided to support rare applications with unusual needs. ** ** The sqlite3_config() interface is not threadsafe. The application ** must insure that no other SQLite interfaces are invoked by other ** threads while sqlite3_config() is running. Furthermore, sqlite3_config() ** may only be invoked prior to library initialization using ** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. ** Note, however, that sqlite3_config() can be called as part of the ** implementation of an application-defined [sqlite3_os_init()]. ** ** The first argument to sqlite3_config() is an integer ** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines ** what property of SQLite is to be configured. Subsequent arguments ** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option] ** in the first argument. ** ** When a configuration option is set, sqlite3_config() returns SQLITE_OK. ** If the option is unknown or SQLite is unable to set the option ** then this routine returns a non-zero [error code]. ** ** The sqlite3_config() interface is considered experimental in that ** new configuration options may be added in future releases and existing ** configuration options may be discontinued or modified. */ int sqlite3_config(int, ...); /* ** CAPI3REF: Memory Allocation Routines {F10155} ** ** An instance of this object defines the interface between SQLite ** and low-level memory allocation routines. ** ** This object is used in only one place in the SQLite interface. ** A pointer to an instance of this object is the argument to ** [sqlite3_config()] when the configuration option is ** [SQLITE_CONFIG_MALLOC]. By creating an instance of this object ** and passing it to [sqlite3_config()] during configuration, an ** application can specify an alternative memory allocation subsystem ** for SQLite to use for all of its dynamic memory needs. ** ** Note that SQLite comes with a built-in memory allocator that is ** perfectly adequate for the overwhelming majority of applications ** and that this object is only useful to a tiny minority of applications ** with specialized memory allocation requirements. This object is ** also used during testing of SQLite in order to specify an alternative ** memory allocator that simulates memory out-of-memory conditions in ** order to verify that SQLite recovers gracefully from such ** conditions. ** ** The xMalloc, xFree, and xRealloc methods must work like the ** malloc(), free(), and realloc() functions from the standard library. ** ** xSize should return the allocated size of a memory allocation ** previously obtained from xMalloc or xRealloc. The allocated size ** is always at least as big as the requested size but may be larger. ** ** The xRoundup method returns what would be the allocated size of ** a memory allocation given a particular requested size. Most memory ** allocators round up memory allocations at least to the next multiple ** of 8. Some allocators round up to a larger multiple or to a power of 2. ** ** The xInit method initializes the memory allocator. (For example, ** it might allocate any require mutexes or initialize internal data ** structures. The xShutdown method is invoked (indirectly) by ** [sqlite3_shutdown()] and should deallocate any resources acquired ** by xInit. The pAppData pointer is used as the only parameter to ** xInit and xShutdown. */ typedef struct sqlite3_mem_methods sqlite3_mem_methods; struct sqlite3_mem_methods { void *(*xMalloc)(int); /* Memory allocation function */ void (*xFree)(void*); /* Free a prior allocation */ void *(*xRealloc)(void*,int); /* Resize an allocation */ int (*xSize)(void*); /* Return the size of an allocation */ int (*xRoundup)(int); /* Round up request size to allocation size */ int (*xInit)(void*); /* Initialize the memory allocator */ void (*xShutdown)(void*); /* Deinitialize the memory allocator */ void *pAppData; /* Argument to xInit() and xShutdown() */ }; /* ** CAPI3REF: Configuration Options {F10160} ** ** These constants are the available integer configuration options that ** can be passed as the first argument to the [sqlite3_config()] interface. ** ** New configuration options may be added in future releases of SQLite. ** Existing configuration options might be discontinued. Applications ** should check the return code from [sqlite3_config()] to make sure that ** the call worked. The [sqlite3_config()] interface will return a ** non-zero [error code] if a discontinued or unsupported configuration option ** is invoked. ** ** <dl> ** <dt>SQLITE_CONFIG_SINGLETHREAD</dt> ** <dd>There are no arguments to this option. This option disables ** all mutexing and puts SQLite into a mode where it can only be used ** by a single thread.</dd> ** ** <dt>SQLITE_CONFIG_MULTITHREAD</dt> ** <dd>There are no arguments to this option. This option disables ** mutexing on [database connection] and [prepared statement] objects. ** The application is responsible for serializing access to ** [database connections] and [prepared statements]. But other mutexes ** are enabled so that SQLite will be safe to use in a multi-threaded ** environment.</dd> ** ** <dt>SQLITE_CONFIG_SERIALIZED</dt> ** <dd>There are no arguments to this option. This option enables ** all mutexes including the recursive ** mutexes on [database connection] and [prepared statement] objects. ** In this mode (which is the default when SQLite is compiled with ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access ** to [database connections] and [prepared statements] so that the ** application is free to use the same [database connection] or the ** same [prepared statement] in different threads at the same time. ** ** <p>This configuration option merely sets the default mutex ** behavior to serialize access to [database connections]. Individual ** [database connections] can override this setting ** using the [SQLITE_OPEN_NOMUTEX] flag to [sqlite3_open_v2()].</p></dd> ** ** <dt>SQLITE_CONFIG_MALLOC</dt> ** <dd>This option takes a single argument which is a pointer to an ** instance of the [sqlite3_mem_methods] structure. The argument specifies ** alternative low-level memory allocation routines to be used in place of ** the memory allocation routines built into SQLite.</dd> ** ** <dt>SQLITE_CONFIG_GETMALLOC</dt> ** <dd>This option takes a single argument which is a pointer to an ** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods] ** structure is filled with the currently defined memory allocation routines. ** This option can be used to overload the default memory allocation ** routines with a wrapper that simulations memory allocation failure or ** tracks memory usage, for example.</dd> ** ** <dt>SQLITE_CONFIG_MEMSTATUS</dt> ** <dd>This option takes single boolean argument which enables or disables ** the collection of memory allocation statistics. When disabled, the ** following SQLite interfaces become non-operational: ** <ul> ** <li> [sqlite3_memory_used()] ** <li> [sqlite3_memory_highwater()] ** <li> [sqlite3_soft_heap_limit()] ** <li> sqlite3_memory_status() ** </ul> ** </dd> ** ** <dt>SQLITE_CONFIG_SCRATCH</dt> ** <dd>This option specifies a static memory buffer that SQLite can use for ** scratch memory. There are three arguments: A pointer to the memory, the ** size of each scratch buffer (sz), and the number of buffers (N). The sz ** argument must be a multiple of 16. The first ** argument should point to an allocation of at least (sz+4)*N bytes of memory. ** SQLite will use no more than one scratch buffer at once per thread, so ** N should be set to the expected maximum number of threads. The sz ** parameter should be 6 times the size of the largest database page size. ** Scratch buffers are used as part of the btree balance operation. If ** The btree balancer needs additional memory beyond what is provided by ** scratch buffers or if no scratch buffer space is specified, then SQLite ** goes to [sqlite3_malloc()] to obtain the memory it needs.</dd> ** ** <dt>SQLITE_CONFIG_PAGECACHE</dt> ** <dd>This option specifies a static memory buffer that SQLite can use for ** the database page cache. There are three arguments: A pointer to the ** memory, the size of each page buffer (sz), and the number of pages (N). ** The sz argument must be a power of two between 512 and 32768. The first ** argument should point to an allocation of at least (sz+4)*N bytes of memory. ** SQLite will use the memory provided by the first argument to satisfy its ** memory needs for the first N pages that it adds to cache. If additional ** page cache memory is needed beyond what is provided by this option, then ** SQLite goes to [sqlite3_malloc()] for the additional storage space.</dd> ** ** <dt>SQLITE_CONFIG_HEAP</dt> ** <dd>This option specifies a static memory buffer that SQLite will use ** for all of its dynamic memory allocation needs beyond those provided ** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. ** There are three arguments: A pointer to the memory, the number of ** bytes in the memory buffer, and the minimum allocation size. If ** the first pointer (the memory pointer) is NULL, then SQLite reverts ** to using its default memory allocator (the system malloc() implementation), ** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. If the ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory ** allocator is engaged to handle all of SQLites memory allocation needs.</dd> ** ** <dt>SQLITE_CONFIG_MUTEX</dt> ** <dd>This option takes a single argument which is a pointer to an ** instance of the [sqlite3_mutex_methods] structure. The argument specifies ** alternative low-level mutex routines to be used in place ** the mutex routines built into SQLite.</dd> ** ** <dt>SQLITE_CONFIG_GETMUTEX</dt> ** <dd>This option takes a single argument which is a pointer to an ** instance of the [sqlite3_mutex_methods] structure. The ** [sqlite3_mutex_methods] ** structure is filled with the currently defined mutex routines. ** This option can be used to overload the default mutex allocation ** routines with a wrapper used to track mutex usage for performance ** profiling or testing, for example.</dd> */ #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ #define SQLITE_CONFIG_SERIALIZED 3 /* nil */ #define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ #define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ #define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ #define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ /* ** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} ** ** The sqlite3_extended_result_codes() routine enables or disables the ** [extended result codes] feature of SQLite. The extended result ** codes are disabled by default for historical compatibility considerations. ** ** INVARIANTS: ** ** {F12201} Each new [database connection] shall have the ** [extended result codes] feature disabled by default. ** ** {F12202} The [sqlite3_extended_result_codes(D,F)] interface shall enable ** [extended result codes] for the [database connection] D ** if the F parameter is true, or disable them if F is false. */ int sqlite3_extended_result_codes(sqlite3*, int onoff); /* ** CAPI3REF: Last Insert Rowid {F12220} ** ** Each entry in an SQLite table has a unique 64-bit signed ................................................................................ ** integer key called the "rowid". The rowid is always available ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those ** names are not also used by explicitly declared columns. If ** the table has a column of type INTEGER PRIMARY KEY then that column ** is another alias for the rowid. ** ** This routine returns the rowid of the most recent ** successful INSERT into the database from the [database connection] ** in the first argument. If no successful INSERTs ** have ever occurred on that database connection, zero is returned. ** ** If an INSERT occurs within a trigger, then the rowid of the inserted ** row is returned by this routine as long as the trigger is running. ** But once the trigger terminates, the value returned by this routine ** reverts to the last value inserted before the trigger fired. ** ** An INSERT that fails due to a constraint violation is not a ** successful INSERT and does not change the value returned by this ** routine. Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, ** and INSERT OR ABORT make no changes to the return value of this ** routine when their insertion fails. When INSERT OR REPLACE ** encounters a constraint violation, it does not fail. The ** INSERT continues to completion after deleting rows that caused ** the constraint problem so INSERT OR REPLACE will always change ** the return value of this interface. ** ** For the purposes of this routine, an INSERT is considered to ** be successful even if it is subsequently rolled back. ** ** INVARIANTS: ** ** {F12221} The [sqlite3_last_insert_rowid()] function returns the rowid ** of the most recent successful INSERT performed on the same ** [database connection] and within the same or higher level ** trigger context, or zero if there have been no qualifying inserts. ** ** {F12223} The [sqlite3_last_insert_rowid()] function returns the ** same value when called from the same trigger context ** immediately before and after a ROLLBACK. ** ** LIMITATIONS: ** ** {A12232} If a separate thread performs a new INSERT on the same ** database connection while the [sqlite3_last_insert_rowid()] ** function is running and thus changes the last insert rowid, ** then the value returned by [sqlite3_last_insert_rowid()] is ** unpredictable and might not equal either the old or the new ** last insert rowid. */ sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); /* ** CAPI3REF: Count The Number Of Rows Modified {F12240} ** ** This function returns the number of database rows that were changed ** or inserted or deleted by the most recently completed SQL statement ** on the [database connection] specified by the first parameter. ** Only changes that are directly specified by the INSERT, UPDATE, ** or DELETE statement are counted. Auxiliary changes caused by ** triggers are not counted. Use the [sqlite3_total_changes()] function ** to find the total number of changes including changes caused by triggers. ** ** A "row change" is a change to a single row of a single table ** caused by an INSERT, DELETE, or UPDATE statement. Rows that ** are changed as side effects of REPLACE constraint resolution, ** rollback, ABORT processing, DROP TABLE, or by any other ................................................................................ ** Calling [sqlite3_exec()] or [sqlite3_step()] recursively does ** not create a new trigger context. ** ** This function returns the number of direct row changes in the ** most recent INSERT, UPDATE, or DELETE statement within the same ** trigger context. ** ** Thus, when called from the top level, this function returns the ** number of changes in the most recent INSERT, UPDATE, or DELETE ** that also occurred at the top level. Within the body of a trigger, ** the sqlite3_changes() interface can be called to find the number of ** changes in the most recently completed INSERT, UPDATE, or DELETE ** statement within the body of the same trigger. ** However, the number returned does not include changes ** caused by subtriggers since those have their own context. ** ** SQLite implements the command "DELETE FROM table" without a WHERE clause ** by dropping and recreating the table. (This is much faster than going ** through and deleting individual elements from the table.) Because of this ** optimization, the deletions in "DELETE FROM table" are not row changes and ** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()] ** functions, regardless of the number of elements that were originally ** in the table. To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** INVARIANTS: ** ** {F12241} The [sqlite3_changes()] function shall return the number of ** row changes caused by the most recent INSERT, UPDATE, ** or DELETE statement on the same database connection and ** within the same or higher trigger context, or zero if there have ** not been any qualifying row changes. ** ** {F12243} Statements of the form "DELETE FROM tablename" with no ** WHERE clause shall cause subsequent calls to ** [sqlite3_changes()] to return zero, regardless of the ** number of rows originally in the table. ** ** LIMITATIONS: ** ** {A12252} If a separate thread makes changes on the same database connection ** while [sqlite3_changes()] is running then the value returned ** is unpredictable and not meaningful. */ int sqlite3_changes(sqlite3*); /* ** CAPI3REF: Total Number Of Rows Modified {F12260} ** ** This function returns the number of row changes caused by INSERT, ** UPDATE or DELETE statements since the [database connection] was opened. ** The count includes all changes from all trigger contexts. However, ** the count does not include changes used to implement REPLACE constraints, ** do rollbacks or ABORT processing, or DROP table processing. ** The changes are counted as soon as the statement that makes them is ** completed (when the statement handle is passed to [sqlite3_reset()] or ** [sqlite3_finalize()]). ** ** SQLite implements the command "DELETE FROM table" without a WHERE clause ** by dropping and recreating the table. (This is much faster than going ** through and deleting individual elements from the table.) Because of this ** optimization, the deletions in "DELETE FROM table" are not row changes and ** will not be counted by the sqlite3_changes() or [sqlite3_total_changes()] ** functions, regardless of the number of elements that were originally ** in the table. To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** See also the [sqlite3_changes()] interface. ** ** INVARIANTS: ** ** {F12261} The [sqlite3_total_changes()] returns the total number ** of row changes caused by INSERT, UPDATE, and/or DELETE ** statements on the same [database connection], in any ** trigger context, since the database connection was created. ** ** {F12263} Statements of the form "DELETE FROM tablename" with no ** WHERE clause shall not change the value returned ** by [sqlite3_total_changes()]. ** ** LIMITATIONS: ** ** {A12264} If a separate thread makes changes on the same database connection ** while [sqlite3_total_changes()] is running then the value ** returned is unpredictable and not meaningful. */ int sqlite3_total_changes(sqlite3*); /* ** CAPI3REF: Interrupt A Long-Running Query {F12270} ** ** This function causes any pending database operation to abort and ................................................................................ ** return at its earliest opportunity. This routine is typically ** called in response to a user action such as pressing "Cancel" ** or Ctrl-C where the user wants a long query operation to halt ** immediately. ** ** It is safe to call this routine from a thread different from the ** thread that is currently running the database operation. But it ** is not safe to call this routine with a [database connection] that ** is closed or might close before sqlite3_interrupt() returns. ** ** If an SQL operation is very nearly finished at the time when ** sqlite3_interrupt() is called, then it might not have an opportunity ** to be interrupted and might continue to completion. ** ** An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. ** If the interrupted SQL operation is an INSERT, UPDATE, or DELETE ** that is inside an explicit transaction, then the entire transaction ** will be rolled back automatically. ** ** A call to sqlite3_interrupt() has no effect on SQL statements ** that are started after sqlite3_interrupt() returns. ** ** INVARIANTS: ** ** {F12271} The [sqlite3_interrupt()] interface will force all running ** SQL statements associated with the same database connection ** to halt after processing at most one additional row of data. ** ** {F12272} Any SQL statement that is interrupted by [sqlite3_interrupt()] ** will return [SQLITE_INTERRUPT]. ** ** LIMITATIONS: ** ** {A12279} If the database connection closes while [sqlite3_interrupt()] ** is running then bad things will likely happen. */ void sqlite3_interrupt(sqlite3*); /* ** CAPI3REF: Determine If An SQL Statement Is Complete {F10510} ** ................................................................................ ** appears to be a complete SQL statement. A statement is judged to be ** complete if it ends with a semicolon token and is not a fragment of a ** CREATE TRIGGER statement. Semicolons that are embedded within ** string literals or quoted identifier names or comments are not ** independent tokens (they are part of the token in which they are ** embedded) and thus do not count as a statement terminator. ** ** These routines do not parse the SQL statements thus ** will not detect syntactically incorrect SQL. ** ** INVARIANTS: ** ** {F10511} A successful evaluation of [sqlite3_complete()] or ** [sqlite3_complete16()] functions shall ** return a numeric 1 if and only if the last non-whitespace ** token in their input is a semicolon that is not in between ** the BEGIN and END of a CREATE TRIGGER statement. ** ** {F10512} If a memory allocation error occurs during an invocation ** of [sqlite3_complete()] or [sqlite3_complete16()] then the ** routine shall return [SQLITE_NOMEM]. ** ** LIMITATIONS: ** ** {A10512} The input to [sqlite3_complete()] must be a zero-terminated ** UTF-8 string. ** ** {A10513} The input to [sqlite3_complete16()] must be a zero-terminated ** UTF-16 string in native byte order. */ int sqlite3_complete(const char *sql); int sqlite3_complete16(const void *sql); /* ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310} ** ** This routine sets a callback function that might be invoked whenever ** an attempt is made to open a database table that another thread ** or process has locked. ** ** If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] ** is returned immediately upon encountering the lock. If the busy callback ** is not NULL, then the callback will be invoked with two arguments. ** ** The first argument to the handler is a copy of the void* pointer which ** is the third argument to sqlite3_busy_handler(). The second argument to ** the handler callback is the number of times that the busy handler has ** been invoked for this locking event. If the ** busy callback returns 0, then no additional attempts are made to ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. ** If the callback returns non-zero, then another attempt ** is made to open the database for reading and the cycle repeats. ** ** The presence of a busy handler does not guarantee that it will be invoked ** when there is lock contention. If SQLite determines that invoking the busy ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] ** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler. ** Consider a scenario where one process is holding a read lock that ** it is trying to promote to a reserved lock and ** a second process is holding a reserved lock that it is trying ** to promote to an exclusive lock. The first process cannot proceed ** because it is blocked by the second and the second process cannot ** proceed because it is blocked by the first. If both processes ** invoke the busy handlers, neither will make any progress. Therefore, ................................................................................ ** to promote this lock to EXCLUSIVE so that it can spill cache ** pages into the database file without harm to concurrent ** readers. If it is unable to promote the lock, then the in-memory ** cache will be left in an inconsistent state and so the error ** code is promoted from the relatively benign [SQLITE_BUSY] to ** the more severe [SQLITE_IOERR_BLOCKED]. This error code promotion ** forces an automatic rollback of the changes. See the ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError"> ** CorruptionFollowingBusyError</a> wiki page for a discussion of why ** this is important. ** ** There can only be a single busy handler defined for each ** [database connection]. Setting a new busy handler clears any ** previously set handler. Note that calling [sqlite3_busy_timeout()] ** will also set or clear the busy handler. ** ** INVARIANTS: ** ** {F12311} The [sqlite3_busy_handler(D,C,A)] function shall replace ** busy callback in the [database connection] D with a new ** a new busy handler C and application data pointer A. ** ** {F12312} Newly created [database connections] shall have a busy ** handler of NULL. ** ** {F12314} When two or more [database connections] share a ** [sqlite3_enable_shared_cache | common cache], ** the busy handler for the database connection currently using ** the cache shall be invoked when the cache encounters a lock. ** ** {F12316} If a busy handler callback returns zero, then the SQLite interface ** that provoked the locking event shall return [SQLITE_BUSY]. ** ** {F12318} SQLite shall invokes the busy handler with two arguments which ** are a copy of the pointer supplied by the 3rd parameter to ** [sqlite3_busy_handler()] and a count of the number of prior ** invocations of the busy handler for the same locking event. ** ** LIMITATIONS: ** ** {A12319} A busy handler must not close the database connection ** or [prepared statement] that invoked the busy handler. */ int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); /* ** CAPI3REF: Set A Busy Timeout {F12340} ** ** This routine sets a [sqlite3_busy_handler | busy handler] that sleeps ** for a specified amount of time when a table is locked. The handler ** will sleep multiple times until at least "ms" milliseconds of sleeping ** have accumulated. {F12343} After "ms" milliseconds of sleeping, ** the handler returns 0 which causes [sqlite3_step()] to return ** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. ** ** Calling this routine with an argument less than or equal to zero ** turns off all busy handlers. ** ** There can only be a single busy handler for a particular ** [database connection] any any given moment. If another busy handler ** was defined (using [sqlite3_busy_handler()]) prior to calling ** this routine, that other busy handler is cleared. ** ** INVARIANTS: ** ** {F12341} The [sqlite3_busy_timeout()] function shall override any prior ** [sqlite3_busy_timeout()] or [sqlite3_busy_handler()] setting ** on the same [database connection]. ** ** {F12343} If the 2nd parameter to [sqlite3_busy_timeout()] is less than ** or equal to zero, then the busy handler shall be cleared so that ** all subsequent locking events immediately return [SQLITE_BUSY]. ** ** {F12344} If the 2nd parameter to [sqlite3_busy_timeout()] is a positive ** number N, then a busy handler shall be set that repeatedly calls ** the xSleep() method in the [sqlite3_vfs | VFS interface] until ** either the lock clears or until the cumulative sleep time ** reported back by xSleep() exceeds N milliseconds. */ int sqlite3_busy_timeout(sqlite3*, int ms); /* ** CAPI3REF: Convenience Routines For Running Queries {F12370} ** ** Definition: A <b>result table</b> is memory data structure created by the ................................................................................ ** complete query results from one or more queries. ** ** The table conceptually has a number of rows and columns. But ** these numbers are not part of the result table itself. These ** numbers are obtained separately. Let N be the number of rows ** and M be the number of columns. ** ** A result table is an array of pointers to zero-terminated UTF-8 strings. ** There are (N+1)*M elements in the array. The first M pointers point ** to zero-terminated strings that contain the names of the columns. ** The remaining entries all point to query results. NULL values result ** in NULL pointers. All other values are in their UTF-8 zero-terminated ** string representation as returned by [sqlite3_column_text()]. ** ** A result table might consist of one or more memory allocations. ** It is not safe to pass a result table directly to [sqlite3_free()]. ** A result table should be deallocated using [sqlite3_free_table()]. ** ** As an example of the result table format, suppose a query result ** is as follows: ** ** <blockquote><pre> ................................................................................ ** </pre></blockquote> ** ** The sqlite3_get_table() function evaluates one or more ** semicolon-separated SQL statements in the zero-terminated UTF-8 ** string of its 2nd parameter. It returns a result table to the ** pointer given in its 3rd parameter. ** ** After the calling function has finished using the result, it should ** pass the pointer to the result table to sqlite3_free_table() in order to ** release the memory that was malloced. Because of the way the ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling ** function must not try to call [sqlite3_free()] directly. Only ** [sqlite3_free_table()] is able to release the memory properly and safely. ** ** The sqlite3_get_table() interface is implemented as a wrapper around ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access ** to any internal data structures of SQLite. It uses only the public ** interface defined here. As a consequence, errors that occur in the ** wrapper layer outside of the internal [sqlite3_exec()] call are not ** reflected in subsequent calls to [sqlite3_errcode()] or [sqlite3_errmsg()]. ** ** INVARIANTS: ** ** {F12371} If a [sqlite3_get_table()] fails a memory allocation, then ** it shall free the result table under construction, abort the ** query in process, skip any subsequent queries, set the ** *pazResult output pointer to NULL and return [SQLITE_NOMEM]. ** ** {F12373} If the pnColumn parameter to [sqlite3_get_table()] is not NULL ** then a successful invocation of [sqlite3_get_table()] shall ** write the number of columns in the ** result set of the query into *pnColumn. ** ** {F12374} If the pnRow parameter to [sqlite3_get_table()] is not NULL ** then a successful invocation of [sqlite3_get_table()] shall ** writes the number of rows in the ** result set of the query into *pnRow. ** ** {F12376} A successful invocation of [sqlite3_get_table()] that computes ** N rows of result with C columns per row shall make *pazResult ** point to an array of pointers to (N+1)*C strings where the first ** C strings are column names as obtained from ** [sqlite3_column_name()] and the rest are column result values ** obtained from [sqlite3_column_text()]. ** ** {F12379} The values in the pazResult array returned by [sqlite3_get_table()] ** shall remain valid until cleared by [sqlite3_free_table()]. ** ** {F12382} When an error occurs during evaluation of [sqlite3_get_table()] ** the function shall set *pazResult to NULL, write an error message ** into memory obtained from [sqlite3_malloc()], make ** **pzErrmsg point to that error message, and return a ** appropriate [error code]. */ int sqlite3_get_table( sqlite3 *db, /* An open database */ const char *zSql, /* SQL to be evaluated */ char ***pazResult, /* Results of the query */ int *pnRow, /* Number of result rows written here */ int *pnColumn, /* Number of result columns written here */ char **pzErrmsg /* Error msg written here */ ); void sqlite3_free_table(char **result); /* ** CAPI3REF: Formatted String Printing Functions {F17400} ** ** These routines are workalikes of the "printf()" family of functions ** from the standard C library. ** ** The sqlite3_mprintf() and sqlite3_vmprintf() routines write their ** results into memory obtained from [sqlite3_malloc()]. ** The strings returned by these two routines should be ** released by [sqlite3_free()]. Both routines return a ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough ** memory to hold the resulting string. ** ** In sqlite3_snprintf() routine is similar to "snprintf()" from ** the standard C library. The result is written into the ** buffer supplied as the second parameter whose size is given by ** the first parameter. Note that the order of the ................................................................................ ** guarantees that the buffer is always zero-terminated. The first ** parameter "n" is the total size of the buffer, including space for ** the zero terminator. So the longest string that can be completely ** written will be n-1 characters. ** ** These routines all implement some additional formatting ** options that are useful for constructing SQL statements. ** All of the usual printf() formatting options apply. In addition, there ** is are "%q", "%Q", and "%z" options. ** ** The %q option works like %s in that it substitutes a null-terminated ** string from the argument list. But %q also doubles every '\'' character. ** %q is designed for use inside a string literal. By doubling each '\'' ** character it escapes that character and allows it to be inserted into ** the string. ** ** For example, assume the string variable zText contains text as follows: ** ** <blockquote><pre> ** char *zText = "It's a happy day!"; ** </pre></blockquote> ** ** One can use this text in an SQL statement as follows: ** ................................................................................ ** This is correct. Had we used %s instead of %q, the generated SQL ** would have looked like this: ** ** <blockquote><pre> ** INSERT INTO table1 VALUES('It's a happy day!'); ** </pre></blockquote> ** ** This second example is an SQL syntax error. As a general rule you should ** always use %q instead of %s when inserting text into a string literal. ** ** The %Q option works like %q except it also adds single quotes around ** the outside of the total string. Additionally, if the parameter in the ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without ** single quotes) in place of the %Q option. So, for example, one could say: ** ** <blockquote><pre> ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText); ** sqlite3_exec(db, zSQL, 0, 0, 0); ** sqlite3_free(zSQL); ** </pre></blockquote> ** ................................................................................ ** memory obtained from [sqlite3_malloc()] or NULL pointers if ** a call to [sqlite3_malloc()] fails. ** ** {F17406} The [sqlite3_snprintf()] interface writes a zero-terminated ** UTF-8 string into the buffer pointed to by the second parameter ** provided that the first parameter is greater than zero. ** ** {F17407} The [sqlite3_snprintf()] interface does not write slots of ** its output buffer (the second parameter) outside the range ** of 0 through N-1 (where N is the first parameter) ** regardless of the length of the string ** requested by the format specification. */ char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); char *sqlite3_snprintf(int,char*,const char*, ...); /* ** CAPI3REF: Memory Allocation Subsystem {F17300} ** ** The SQLite core uses these three routines for all of its own ** internal memory allocation needs. "Core" in the previous sentence ** does not include operating-system specific VFS implementation. The ** Windows VFS uses native malloc() and free() for some operations. ** ** The sqlite3_malloc() routine returns a pointer to a block ** of memory at least N bytes in length, where N is the parameter. ** If sqlite3_malloc() is unable to obtain sufficient free ** memory, it returns a NULL pointer. If the parameter N to ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns ** a NULL pointer. ................................................................................ ** second parameter. The memory allocation to be resized is the first ** parameter. If the first parameter to sqlite3_realloc() ** is a NULL pointer then its behavior is identical to calling ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). ** If the second parameter to sqlite3_realloc() is zero or ** negative then the behavior is exactly the same as calling ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). ** sqlite3_realloc() returns a pointer to a memory allocation ** of at least N bytes in size or NULL if sufficient memory is unavailable. ** If M is the size of the prior allocation, then min(N,M) bytes ** of the prior allocation are copied into the beginning of buffer returned ** by sqlite3_realloc() and the prior allocation is freed. ** If sqlite3_realloc() returns NULL, then the prior allocation ** is not freed. ** ** The memory returned by sqlite3_malloc() and sqlite3_realloc() ** is always aligned to at least an 8 byte boundary. {END} ** ** The default implementation of the memory allocation subsystem uses ** the malloc(), realloc() and free() provided by the standard C library. ** {F17382} However, if SQLite is compiled with the ** SQLITE_MEMORY_SIZE=<i>NNN</i> C preprocessor macro (where <i>NNN</i> ** is an integer), then SQLite create a static array of at least ** <i>NNN</i> bytes in size and uses that array for all of its dynamic ** memory allocation needs. {END} Additional memory allocator options ** may be added in future releases. ** ** In SQLite version 3.5.0 and 3.5.1, it was possible to define ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in ** implementation of these routines to be omitted. That capability ** is no longer provided. Only built-in memory allocators can be used. ** ** The Windows OS interface layer calls ** the system malloc() and free() directly when converting ** filenames between the UTF-8 encoding used by SQLite ** and whatever filename encoding is used by the particular Windows ** installation. Memory allocation errors are detected, but ** they are reported back as [SQLITE_CANTOPEN] or ** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. ** ** INVARIANTS: ** ** {F17303} The [sqlite3_malloc(N)] interface returns either a pointer to ** a newly checked-out block of at least N bytes of memory ** that is 8-byte aligned, or it returns NULL if it is unable ** to fulfill the request. ** ** {F17304} The [sqlite3_malloc(N)] interface returns a NULL pointer if ** N is less than or equal to zero. ** ** {F17305} The [sqlite3_free(P)] interface releases memory previously ** returned from [sqlite3_malloc()] or [sqlite3_realloc()], ** making it available for reuse. ................................................................................ ** deallocation needs. ** ** {F17318} The [sqlite3_realloc(P,N)] interface returns either a pointer ** to a block of checked-out memory of at least N bytes in size ** that is 8-byte aligned, or a NULL pointer. ** ** {F17321} When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first ** copies the first K bytes of content from P into the newly ** allocated block, where K is the lesser of N and the size of ** the buffer P. ** ** {F17322} When [sqlite3_realloc(P,N)] returns a non-NULL pointer, it first ** releases the buffer P. ** ** {F17323} When [sqlite3_realloc(P,N)] returns NULL, the buffer P is ** not modified or released. ** ** LIMITATIONS: ** ** {A17350} The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] ** must be either NULL or else pointers obtained from a prior ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have ** not yet been released. ** ** {A17351} The application must not read or write any part of ** a block of memory after it has been released using ** [sqlite3_free()] or [sqlite3_realloc()]. */ void *sqlite3_malloc(int); void *sqlite3_realloc(void*, int); void sqlite3_free(void*); /* ** CAPI3REF: Memory Allocator Statistics {F17370} ** ** SQLite provides these two interfaces for reporting on the status ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] ** routines, which form the built-in memory allocation subsystem. ** ** INVARIANTS: ** ** {F17371} The [sqlite3_memory_used()] routine returns the number of bytes ** of memory currently outstanding (malloced but not freed). ** ** {F17373} The [sqlite3_memory_highwater()] routine returns the maximum ** value of [sqlite3_memory_used()] since the high-water mark ** was last reset. ** ** {F17374} The values returned by [sqlite3_memory_used()] and ** [sqlite3_memory_highwater()] include any overhead ** added by SQLite in its implementation of [sqlite3_malloc()], ** but not overhead added by the any underlying system library ** routines that [sqlite3_malloc()] may call. ** ** {F17375} The memory high-water mark is reset to the current value of ** [sqlite3_memory_used()] if and only if the parameter to ** [sqlite3_memory_highwater()] is true. The value returned ** by [sqlite3_memory_highwater(1)] is the high-water mark ** prior to the reset. */ sqlite3_int64 sqlite3_memory_used(void); sqlite3_int64 sqlite3_memory_highwater(int resetFlag); /* ** CAPI3REF: Pseudo-Random Number Generator {F17390} ** ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to ** select random ROWIDs when inserting new records into a table that ** already uses the largest possible ROWID. The PRNG is also used for ** the build-in random() and randomblob() SQL functions. This interface allows ** applications to access the same PRNG for other purposes. ** ** A call to this routine stores N bytes of randomness into buffer P. ** ** The first time this routine is invoked (either internally or by ** the application) the PRNG is seeded using randomness obtained ** from the xRandomness method of the default [sqlite3_vfs] object. ** On all subsequent invocations, the pseudo-randomness is generated ................................................................................ ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. At various ** points during the compilation process, as logic is being created ** to perform various actions, the authorizer callback is invoked to ** see if those actions are allowed. The authorizer callback should ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the ** specific action but allow the SQL statement to continue to be ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be ** rejected with an error. If the authorizer callback returns ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] ** then the [sqlite3_prepare_v2()] or equivalent call that triggered ** the authorizer will fail with an error message. ** ** When the callback returns [SQLITE_OK], that means the operation ** requested is ok. When the callback returns [SQLITE_DENY], the ** [sqlite3_prepare_v2()] or equivalent call that triggered the ** authorizer will fail with an error message explaining that ** access is denied. If the authorizer code is [SQLITE_READ] ................................................................................ ** and the callback returns [SQLITE_IGNORE] then the ** [prepared statement] statement is constructed to substitute ** a NULL value in place of the table column that would have ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] ** return can be used to deny an untrusted user access to individual ** columns of a table. ** ** The first parameter to the authorizer callback is a copy of the third ** parameter to the sqlite3_set_authorizer() interface. The second parameter ** to the callback is an integer [SQLITE_COPY | action code] that specifies ** the particular action to be authorized. The third through sixth parameters ** to the callback are zero-terminated strings that contain additional ** details about the action to be authorized. ** ** An authorizer is used when [sqlite3_prepare | preparing] ** SQL statements from an untrusted source, to ensure that the SQL statements ** do not try to access data they are not allowed to see, or that they do not ** try to execute malicious statements that damage the database. For ** example, an application may allow a user to enter arbitrary ** SQL queries for evaluation by a database. But the application does ** not want the user to be able to make arbitrary changes to the ** database. An authorizer could then be put in place while the ** user-entered SQL is being [sqlite3_prepare | prepared] that ** disallows everything except [SELECT] statements. ** ................................................................................ ** in addition to using an authorizer. ** ** Only a single authorizer can be in place on a database connection ** at a time. Each call to sqlite3_set_authorizer overrides the ** previous call. Disable the authorizer by installing a NULL callback. ** The authorizer is disabled by default. ** ** Note that the authorizer callback is invoked only during ** [sqlite3_prepare()] or its variants. Authorization is not ** performed during statement evaluation in [sqlite3_step()]. ** ** INVARIANTS: ** ** {F12501} The [sqlite3_set_authorizer(D,...)] interface registers a ** authorizer callback with database connection D. ** ** {F12502} The authorizer callback is invoked as SQL statements are ** being compiled. ** ** {F12503} If the authorizer callback returns any value other than ** [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY], then ** the [sqlite3_prepare_v2()] or equivalent call that caused ** the authorizer callback to run shall fail with an ** [SQLITE_ERROR] error code and an appropriate error message. ** ** {F12504} When the authorizer callback returns [SQLITE_OK], the operation ** described is processed normally. ** ** {F12505} When the authorizer callback returns [SQLITE_DENY], the ** [sqlite3_prepare_v2()] or equivalent call that caused the ** authorizer callback to run shall fail ** with an [SQLITE_ERROR] error code and an error message ** explaining that access is denied. ** ** {F12506} If the authorizer code (the 2nd parameter to the authorizer ** callback) is [SQLITE_READ] and the authorizer callback returns ** [SQLITE_IGNORE], then the prepared statement is constructed to ** insert a NULL value in place of the table column that would have ** been read if [SQLITE_OK] had been returned. ** ** {F12507} If the authorizer code (the 2nd parameter to the authorizer ** callback) is anything other than [SQLITE_READ], then ** a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. ** ** {F12510} The first parameter to the authorizer callback is a copy of ** the third parameter to the [sqlite3_set_authorizer()] interface. ** ** {F12511} The second parameter to the callback is an integer ** [SQLITE_COPY | action code] that specifies the particular action ** to be authorized. ** ** {F12512} The third through sixth parameters to the callback are ** zero-terminated strings that contain ** additional details about the action to be authorized. ** ** {F12520} Each call to [sqlite3_set_authorizer()] overrides ** any previously installed authorizer. ** ** {F12521} A NULL authorizer means that no authorization ** callback is invoked. ** ** {F12522} The default authorizer is NULL. */ ................................................................................ #define SQLITE_DENY 1 /* Abort the SQL statement with an error */ #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ /* ** CAPI3REF: Authorizer Action Codes {F12550} ** ** The [sqlite3_set_authorizer()] interface registers a callback function ** that is invoked to authorize certain SQL statement actions. The ** second parameter to the callback is an integer code that specifies ** what action is being authorized. These are the integer action codes that ** the authorizer callback may be passed. ** ** These action code values signify what kind of operation is to be ** authorized. The 3rd and 4th parameters to the authorization ** callback function will be parameters or NULL depending on which of these ** codes is used as the second parameter. The 5th parameter to the ** authorizer callback is the name of the database ("main", "temp", ** etc.) if applicable. The 6th parameter to the authorizer callback ** is the name of the inner-most trigger or view that is responsible for ** the access attempt or NULL if this access attempt is directly from ** top-level SQL code. ** ** INVARIANTS: ** ** {F12551} The second parameter to an ** [sqlite3_set_authorizer | authorizer callback] is always an integer ** [SQLITE_COPY | authorizer code] that specifies what action ** is being authorized. ** ** {F12552} The 3rd and 4th parameters to the ** [sqlite3_set_authorizer | authorization callback] ** will be parameters or NULL depending on which ** [SQLITE_COPY | authorizer code] is used as the second parameter. ** ** {F12553} The 5th parameter to the ** [sqlite3_set_authorizer | authorizer callback] is the name ** of the database (example: "main", "temp", etc.) if applicable. ** ** {F12554} The 6th parameter to the ** [sqlite3_set_authorizer | authorizer callback] is the name ** of the inner-most trigger or view that is responsible for ** the access attempt or NULL if this access attempt is directly from ** top-level SQL code. */ /******************************************* 3rd ************ 4th ***********/ #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ ................................................................................ ** These routines register callback functions that can be used for ** tracing and profiling the execution of SQL statements. ** ** The callback function registered by sqlite3_trace() is invoked at ** various times when an SQL statement is being run by [sqlite3_step()]. ** The callback returns a UTF-8 rendering of the SQL statement text ** as the statement first begins executing. Additional callbacks occur ** as each triggered subprogram is entered. The callbacks for triggers ** contain a UTF-8 SQL comment that identifies the trigger. ** ** The callback function registered by sqlite3_profile() is invoked ** as each SQL statement finishes. The profile callback contains ** the original statement text and an estimate of wall-clock time ** of how long that statement took to run. ** ** The sqlite3_profile() API is currently considered experimental and ** is subject to change or removal in a future release. ** ** The trigger reporting feature of the trace callback is considered ** experimental and is subject to change or removal in future releases. ** Future versions of SQLite might also add new trace callback ** invocations. ** ** INVARIANTS: ** ** {F12281} The callback function registered by [sqlite3_trace()] is ** whenever an SQL statement first begins to execute and ** whenever a trigger subprogram first begins to run. ................................................................................ ** ** {F12283} A NULL trace callback disables tracing. ** ** {F12284} The first argument to the trace callback is a copy of ** the pointer which was the 3rd argument to [sqlite3_trace()]. ** ** {F12285} The second argument to the trace callback is a ** zero-terminated UTF-8 string containing the original text ** of the SQL statement as it was passed into [sqlite3_prepare_v2()] ** or the equivalent, or an SQL comment indicating the beginning ** of a trigger subprogram. ** ** {F12287} The callback function registered by [sqlite3_profile()] is invoked ** as each SQL statement finishes. ** ................................................................................ ** the 3rd parameter to [sqlite3_profile()]. ** ** {F12289} The second parameter to the profile callback is a ** zero-terminated UTF-8 string that contains the complete text of ** the SQL statement as it was processed by [sqlite3_prepare_v2()] ** or the equivalent. ** ** {F12290} The third parameter to the profile callback is an estimate ** of the number of nanoseconds of wall-clock time required to ** run the SQL statement from start to finish. */ void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); void *sqlite3_profile(sqlite3*, void(*xProfile)(void*,const char*,sqlite3_uint64), void*); /* ** CAPI3REF: Query Progress Callbacks {F12910} ** ** This routine configures a callback function - the ** progress callback - that is invoked periodically during long ** running calls to [sqlite3_exec()], [sqlite3_step()] and ** [sqlite3_get_table()]. An example use for this ** interface is to keep a GUI updated during a large query. ** ** If the progress callback returns non-zero, the operation is ** interrupted. This feature can be used to implement a ** "Cancel" button on a GUI dialog box. ** ** INVARIANTS: ** ** {F12911} The callback function registered by sqlite3_progress_handler() ** is invoked periodically during long running calls to ** [sqlite3_step()]. ** ** {F12912} The progress callback is invoked once for every N virtual ** machine opcodes, where N is the second argument to ** the [sqlite3_progress_handler()] call that registered ** the callback. If N is less than 1, sqlite3_progress_handler() ** acts as if a NULL progress handler had been specified. ** ** {F12913} The progress callback itself is identified by the third ** argument to sqlite3_progress_handler(). ** ** {F12914} The fourth argument to sqlite3_progress_handler() is a ** void pointer passed to the progress callback ** function each time it is invoked. ** ** {F12915} If a call to [sqlite3_step()] results in fewer than N opcodes ** being executed, then the progress callback is never invoked. ** ** {F12916} Every call to [sqlite3_progress_handler()] ** overwrites any previously registered progress handler. ** ** {F12917} If the progress handler callback is NULL then no progress ** handler is invoked. ** ** {F12918} If the progress callback returns a result other than 0, then ** the behavior is a if [sqlite3_interrupt()] had been called. */ void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); /* ** CAPI3REF: Opening A New Database Connection {F12700} ** ** These routines open an SQLite database file whose name is given by the ** filename argument. The filename argument is interpreted as UTF-8 for ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte ** order for sqlite3_open16(). A [database connection] handle is usually ** returned in *ppDb, even if an error occurs. The only exception is that ** if SQLite is unable to allocate memory to hold the [sqlite3] object, ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] ** object. If the database is opened (and/or created) successfully, then ** [SQLITE_OK] is returned. Otherwise an [error code] is returned. The ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain ** an English language description of the error. ** ** The default encoding for the database will be UTF-8 if ** sqlite3_open() or sqlite3_open_v2() is called and ** UTF-16 in the native byte order if sqlite3_open16() is used. ** ** Whether or not an error occurs when it is opened, resources ** associated with the [database connection] handle should be released by ** passing it to [sqlite3_close()] when it is no longer required. ** ** The sqlite3_open_v2() interface works like sqlite3_open() ** except that it accepts two additional parameters for additional control ** over the new database connection. The flags parameter can take one of ** the following three values, optionally combined with the ** [SQLITE_OPEN_NOMUTEX] flag: ** ** <dl> ** <dt>[SQLITE_OPEN_READONLY]</dt> ** <dd>The database is opened in read-only mode. If the database does not ** already exist, an error is returned.</dd> ** ** <dt>[SQLITE_OPEN_READWRITE]</dt> ** <dd>The database is opened for reading and writing if possible, or reading ** only if the file is write protected by the operating system. In either ** case the database must already exist, otherwise an error is returned.</dd> ** ** <dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt> ** <dd>The database is opened for reading and writing, and is creates it if ** it does not already exist. This is the behavior that is always used for ** sqlite3_open() and sqlite3_open16().</dd> ** </dl> ** ** If the 3rd parameter to sqlite3_open_v2() is not one of the ** combinations shown above or one of the combinations shown above combined ** with the [SQLITE_OPEN_NOMUTEX] flag, then the behavior is undefined. ** ** If the [SQLITE_OPEN_NOMUTEX] flag is set, then mutexes on the ** opened [database connection] are disabled and the appliation must ** insure that access to the [database connection] and its associated ** [prepared statements] is serialized. The [SQLITE_OPEN_NOMUTEX] flag ** is the default behavior is SQLite is configured using the ** [SQLITE_CONFIG_MULTITHREAD] or [SQLITE_CONFIG_SINGLETHREAD] options ** to [sqlite3_config()]. The [SQLITE_OPEN_NOMUTEX] flag only makes a ** difference when SQLite is in its default [SQLITE_CONFIG_SERIALIZED] mode. ** ** If the filename is ":memory:", then a private, temporary in-memory database ** is created for the connection. This in-memory database will vanish when ** the database connection is closed. Future versions of SQLite might ** make use of additional special filenames that begin with the ":" character. ** It is recommended that when a database filename actually does begin with ** a ":" character you should prefix the filename with a pathname such as ** "./" to avoid ambiguity. ** ** If the filename is an empty string, then a private, temporary ** on-disk database will be created. This private database will be ** automatically deleted as soon as the database connection is closed. ** ** The fourth parameter to sqlite3_open_v2() is the name of the ** [sqlite3_vfs] object that defines the operating system interface that ** the new database connection should use. If the fourth parameter is ** a NULL pointer then the default [sqlite3_vfs] object is used. ** ** <b>Note to Windows users:</b> The encoding used for the filename argument ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever ** codepage is currently defined. Filenames containing international ** characters must be converted to UTF-8 prior to passing them into ** sqlite3_open() or sqlite3_open_v2(). ** ** INVARIANTS: ** ** {F12701} The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces create a new ** [database connection] associated with ** the database file given in their first parameter. ** ** {F12702} The filename argument is interpreted as UTF-8 ** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 ** in the native byte order for [sqlite3_open16()]. ** ** {F12703} A successful invocation of [sqlite3_open()], [sqlite3_open16()], ** or [sqlite3_open_v2()] writes a pointer to a new ** [database connection] into *ppDb. ** ** {F12704} The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces return [SQLITE_OK] upon success, ** or an appropriate [error code] on failure. ** ................................................................................ ** {F12717} If the filename argument to [sqlite3_open()], [sqlite3_open16()], ** or [sqlite3_open_v2()] is ":memory:", then an private, ** ephemeral, in-memory database is created for the connection. ** <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required ** in sqlite3_open_v2()?</todo> ** ** {F12719} If the filename is NULL or an empty string, then a private, ** ephemeral on-disk database will be created. ** <todo>Is SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE required ** in sqlite3_open_v2()?</todo> ** ** {F12721} The [database connection] created by [sqlite3_open_v2(F,D,G,V)] ** will use the [sqlite3_vfs] object identified by the V parameter, ** or the default [sqlite3_vfs] object if V is a NULL pointer. ** ** {F12723} Two [database connections] will share a common cache if both were ** opened with the same VFS while [shared cache mode] was enabled and ** if both filenames compare equal using memcmp() after having been ** processed by the [sqlite3_vfs | xFullPathname] method of the VFS. */ int sqlite3_open( const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb /* OUT: SQLite db handle */ ); int sqlite3_open16( const void *filename, /* Database filename (UTF-16) */ ................................................................................ int flags, /* Flags */ const char *zVfs /* Name of VFS module to use */ ); /* ** CAPI3REF: Error Codes And Messages {F12800} ** ** The sqlite3_errcode() interface returns the numeric [result code] or ** [extended result code] for the most recent failed sqlite3_* API call ** associated with a [database connection]. If a prior API call failed ** but the most recent API call succeeded, the return value from ** sqlite3_errcode() is undefined. ** ** The sqlite3_errmsg() and sqlite3_errmsg16() return English-language ** text that describes the error, as either UTF-8 or UTF-16 respectively. ** Memory to hold the error message string is managed internally. ** The application does not need to worry about freeing the result. ** However, the error string might be overwritten or deallocated by ** subsequent calls to other SQLite interface functions. ** ** If an interface fails with SQLITE_MISUSE, that means the interface ** was invoked incorrectly by the application. In that case, the ** error code and message may or may not be set. ** ** INVARIANTS: ** ** {F12801} The [sqlite3_errcode(D)] interface returns the numeric ** [result code] or [extended result code] for the most recently ** failed interface call associated with the [database connection] D. ** ** {F12803} The [sqlite3_errmsg(D)] and [sqlite3_errmsg16(D)] ** interfaces return English-language text that describes ** the error in the mostly recently failed interface call, ** encoded as either UTF-8 or UTF-16 respectively. ** ** {F12807} The strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()] ** are valid until the next SQLite interface call. ** ** {F12808} Calls to API routines that do not return an error code ** (example: [sqlite3_data_count()]) do not ** change the error code or message returned by ................................................................................ const char *sqlite3_errmsg(sqlite3*); const void *sqlite3_errmsg16(sqlite3*); /* ** CAPI3REF: SQL Statement Object {F13000} ** KEYWORDS: {prepared statement} {prepared statements} ** ** An instance of this object represents a single SQL statement. ** This object is variously known as a "prepared statement" or a ** "compiled SQL statement" or simply as a "statement". ** ** The life of a statement object goes something like this: ** ** <ol> ** <li> Create the object using [sqlite3_prepare_v2()] or a related ** function. ** <li> Bind values to [host parameters] using the sqlite3_bind_*() ** interfaces. ** <li> Run the SQL by calling [sqlite3_step()] one or more times. ** <li> Reset the statement using [sqlite3_reset()] then go back ** to step 2. Do this zero or more times. ** <li> Destroy the object using [sqlite3_finalize()]. ** </ol> ** ** Refer to documentation on individual methods above for additional ................................................................................ ** [database connection] whose limit is to be set or queried. The ** second parameter is one of the [limit categories] that define a ** class of constructs to be size limited. The third parameter is the ** new limit for that construct. The function returns the old limit. ** ** If the new limit is a negative number, the limit is unchanged. ** For the limit category of SQLITE_LIMIT_XYZ there is a hard upper ** bound set by a compile-time C preprocessor macro named SQLITE_MAX_XYZ. ** (The "_LIMIT_" in the name is changed to "_MAX_".) ** Attempts to increase a limit above its hard upper bound are ** silently truncated to the hard upper limit. ** ** Run time limits are intended for use in applications that manage ** both their own internal database and also databases that are controlled ** by untrusted external sources. An example application might be a ** webbrowser that has its own databases for storing history and ** separate databases controlled by JavaScript applications downloaded ** off the Internet. The internal databases can be given the ** large, default limits. Databases managed by external sources can ** be given much smaller limits designed to prevent a denial of service ** attack. Developers might also want to use the [sqlite3_set_authorizer()] ** interface to further control untrusted SQL. The size of the database ** created by an untrusted script can be contained using the ** [max_page_count] [PRAGMA]. ** ** New run-time limit categories may be added in future releases. ** ** INVARIANTS: ** ** {F12762} A successful call to [sqlite3_limit(D,C,V)] where V is ** positive changes the limit on the size of construct C in the ** [database connection] D to the lesser of V and the hard upper ** bound on the size of C that is set at compile-time. ** ** {F12766} A successful call to [sqlite3_limit(D,C,V)] where V is negative ** leaves the state of the [database connection] D unchanged. ** ** {F12769} A successful call to [sqlite3_limit(D,C,V)] returns the ** value of the limit on the size of construct C in the ** [database connection] D as it was prior to the call. */ int sqlite3_limit(sqlite3*, int id, int newVal); /* ** CAPI3REF: Run-Time Limit Categories {F12790} ** KEYWORDS: {limit category} {limit categories} ** ** These constants define various aspects of a [database connection] ** that can be limited in size by calls to [sqlite3_limit()]. ** The meanings of the various limits are as follows: ** ** <dl> ** <dt>SQLITE_LIMIT_LENGTH</dt> ** <dd>The maximum size of any string or BLOB or table row.<dd> ** ** <dt>SQLITE_LIMIT_SQL_LENGTH</dt> ** <dd>The maximum length of an SQL statement.</dd> ** ** <dt>SQLITE_LIMIT_COLUMN</dt> ** <dd>The maximum number of columns in a table definition or in the ** result set of a SELECT or the maximum number of columns in an index ................................................................................ #define SQLITE_LIMIT_FUNCTION_ARG 6 #define SQLITE_LIMIT_ATTACHED 7 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 /* ** CAPI3REF: Compiling An SQL Statement {F13010} ** KEYWORDS: {SQL statement compiler} ** ** To execute an SQL query, it must first be compiled into a byte-code ** program using one of these routines. ** ** The first argument, "db", is a [database connection] obtained from a ** prior call to [sqlite3_open()], [sqlite3_open_v2()] or [sqlite3_open16()]. ** ** The second argument, "zSql", is the statement to be compiled, encoded ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() ** use UTF-16. ** ** If the nByte argument is less than zero, then zSql is read up to the ** first zero terminator. If nByte is non-negative, then it is the maximum ** number of bytes read from zSql. When nByte is non-negative, the ** zSql string ends at either the first '\000' or '\u0000' character or ** the nByte-th byte, whichever comes first. If the caller knows ** that the supplied string is nul-terminated, then there is a small ** performance advantage to be gained by passing an nByte parameter that ** is equal to the number of bytes in the input string <i>including</i> ** the nul-terminator bytes. ** ** *pzTail is made to point to the first byte past the end of the ** first SQL statement in zSql. These routines only compile the first ** statement in zSql, so *pzTail is left pointing to what remains ** uncompiled. ** ** *ppStmt is left pointing to a compiled [prepared statement] that can be ** executed using [sqlite3_step()]. If there is an error, *ppStmt is set ** to NULL. If the input text contains no SQL (if the input is an empty ** string or a comment) then *ppStmt is set to NULL. ** {A13018} The calling procedure is responsible for deleting the compiled ** SQL statement using [sqlite3_finalize()] after it has finished with it. ** ** On success, [SQLITE_OK] is returned, otherwise an [error code] is returned. ** ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are ** recommended for all new programs. The two older interfaces are retained ** for backwards compatibility, but their use is discouraged. ** In the "v2" interfaces, the prepared statement ** that is returned (the [sqlite3_stmt] object) contains a copy of the ** original SQL text. This causes the [sqlite3_step()] interface to ** behave a differently in two ways: ** ** <ol> ** <li> ** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it ** always used to do, [sqlite3_step()] will automatically recompile the SQL ** statement and try to run it again. If the schema has changed in ** a way that makes the statement no longer valid, [sqlite3_step()] will still ** return [SQLITE_SCHEMA]. But unlike the legacy behavior, [SQLITE_SCHEMA] is ** now a fatal error. Calling [sqlite3_prepare_v2()] again will not make the ** error go away. Note: use [sqlite3_errmsg()] to find the text ** of the parsing error that results in an [SQLITE_SCHEMA] return. ** </li> ** ** <li> ** When an error occurs, [sqlite3_step()] will return one of the detailed ** [error codes] or [extended error codes]. The legacy behavior was that ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code ** and you would have to make a second call to [sqlite3_reset()] in order ** to find the underlying cause of the problem. With the "v2" prepare ** interfaces, the underlying reason for the error is returned immediately. ** </li> ** </ol> ** ** INVARIANTS: ** ** {F13011} The [sqlite3_prepare(db,zSql,...)] and ** [sqlite3_prepare_v2(db,zSql,...)] interfaces interpret the ................................................................................ ** text in their zSql parameter as UTF-8. ** ** {F13012} The [sqlite3_prepare16(db,zSql,...)] and ** [sqlite3_prepare16_v2(db,zSql,...)] interfaces interpret the ** text in their zSql parameter as UTF-16 in the native byte order. ** ** {F13013} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)] ** and its variants is less than zero, the SQL text is ** read from zSql is read up to the first zero terminator. ** ** {F13014} If the nByte argument to [sqlite3_prepare_v2(db,zSql,nByte,...)] ** and its variants is non-negative, then at most nBytes bytes of ** SQL text is read from zSql. ** ** {F13015} In [sqlite3_prepare_v2(db,zSql,N,P,pzTail)] and its variants ** if the zSql input text contains more than one SQL statement ** and pzTail is not NULL, then *pzTail is made to point to the ** first byte past the end of the first SQL statement in zSql. ** <todo>What does *pzTail point to if there is one statement?</todo> ** ** {F13016} A successful call to [sqlite3_prepare_v2(db,zSql,N,ppStmt,...)] ** or one of its variants writes into *ppStmt a pointer to a new ** [prepared statement] or a pointer to NULL if zSql contains ** nothing other than whitespace or comments. ** ** {F13019} The [sqlite3_prepare_v2()] interface and its variants return ** [SQLITE_OK] or an appropriate [error code] upon failure. ** ** {F13021} Before [sqlite3_prepare(db,zSql,nByte,ppStmt,pzTail)] or its ** variants returns an error (any value other than [SQLITE_OK]), ** they first set *ppStmt to NULL. */ int sqlite3_prepare( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const char **pzTail /* OUT: Pointer to unused portion of zSql */ ................................................................................ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); /* ** CAPIREF: Retrieving Statement SQL {F13100} ** ** This interface can be used to retrieve a saved copy of the original ** SQL text used to create a [prepared statement] if that statement was ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. ** ** INVARIANTS: ** ** {F13101} If the [prepared statement] passed as the argument to ** [sqlite3_sql()] was compiled using either [sqlite3_prepare_v2()] or ** [sqlite3_prepare16_v2()], then [sqlite3_sql()] returns ** a pointer to a zero-terminated string containing a UTF-8 rendering ** of the original SQL statement. ** ** {F13102} If the [prepared statement] passed as the argument to ** [sqlite3_sql()] was compiled using either [sqlite3_prepare()] or ** [sqlite3_prepare16()], then [sqlite3_sql()] returns a NULL pointer. ** ** {F13103} The string returned by [sqlite3_sql(S)] is valid until the ** [prepared statement] S is deleted using [sqlite3_finalize(S)]. */ const char *sqlite3_sql(sqlite3_stmt *pStmt); /* ** CAPI3REF: Dynamically Typed Value Object {F15000} ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} ** ** SQLite uses the sqlite3_value object to represent all values ** that can be stored in a database table. SQLite uses dynamic typing ** for the values it stores. Values stored in sqlite3_value objects ** can be integers, floating point values, strings, BLOBs, or NULL. ** ** An sqlite3_value object may be either "protected" or "unprotected". ** Some interfaces require a protected sqlite3_value. Other interfaces ** will accept either a protected or an unprotected sqlite3_value. ** Every interface that accepts sqlite3_value arguments specifies ** whether or not it requires a protected sqlite3_value. ** ** The terms "protected" and "unprotected" refer to whether or not ** a mutex is held. A internal mutex is held for a protected ** sqlite3_value object but no mutex is held for an unprotected ** sqlite3_value object. If SQLite is compiled to be single-threaded ** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) ** or if SQLite is run in one of reduced mutex modes ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] ** then there is no distinction between protected and unprotected ** sqlite3_value objects and they can be used interchangeably. However, ** for maximum code portability it is recommended that applications ** still make the distinction between between protected and unprotected ** sqlite3_value objects even when not strictly required. ** ** The sqlite3_value objects that are passed as parameters into the ** implementation of [application-defined SQL functions] are protected. ** The sqlite3_value object returned by ** [sqlite3_column_value()] is unprotected. ** Unprotected sqlite3_value objects may only be used with ** [sqlite3_result_value()] and [sqlite3_bind_value()]. ** The [sqlite3_value_blob | sqlite3_value_type()] family of ** interfaces require protected sqlite3_value objects. */ typedef struct Mem sqlite3_value; /* ** CAPI3REF: SQL Function Context Object {F16001} ** ** The context in which an SQL function executes is stored in an ** sqlite3_context object. A pointer to an sqlite3_context object ** is always first parameter to [application-defined SQL functions]. ** The application-defined SQL function implementation will pass this ** pointer through into calls to [sqlite3_result_int | sqlite3_result()], ** [sqlite3_aggregate_context()], [sqlite3_user_data()], ** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], ** and/or [sqlite3_set_auxdata()]. */ typedef struct sqlite3_context sqlite3_context; /* ** CAPI3REF: Binding Values To Prepared Statements {F13500} ** KEYWORDS: {host parameter} {host parameters} {host parameter name} ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} ** ** In the SQL strings input to [sqlite3_prepare_v2()] and its variants, ** literals may be replaced by a parameter in one of these forms: ** ** <ul> ** <li> ? ** <li> ?NNN ** <li> :VVV ** <li> @VVV ** <li> $VVV ** </ul> ** ** In the parameter forms shown above NNN is an integer literal, ** and VVV is an alpha-numeric parameter name. The values of these ** parameters (also called "host parameter names" or "SQL parameters") ** can be set using the sqlite3_bind_*() routines defined here. ** ** The first argument to the sqlite3_bind_*() routines is always ** a pointer to the [sqlite3_stmt] object returned from ** [sqlite3_prepare_v2()] or its variants. ** ** The second argument is the index of the SQL parameter to be set. ** The leftmost SQL parameter has an index of 1. When the same named ** SQL parameter is used more than once, second and subsequent ** occurrences have the same index as the first occurrence. ** The index for named parameters can be looked up using the ** [sqlite3_bind_parameter_index()] API if desired. The index ** for "?NNN" parameters is the value of NNN. ** The NNN value must be between 1 and the [sqlite3_limit()] ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). ** ** The third argument is the value to bind to the parameter. ** ** In those routines that have a fourth argument, its value is the ** number of bytes in the parameter. To be clear: the value is the ** number of <u>bytes</u> in the value, not the number of characters. ** If the fourth parameter is negative, the length of the string is ** the number of bytes up to the first zero terminator. ** ** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or ** string after SQLite has finished with it. If the fifth argument is ** the special value [SQLITE_STATIC], then SQLite assumes that the ** information is in static, unmanaged space and does not need to be freed. ** If the fifth argument has the value [SQLITE_TRANSIENT], then ** SQLite makes its own private copy of the data immediately, before ** the sqlite3_bind_*() routine returns. ** ** The sqlite3_bind_zeroblob() routine binds a BLOB of length N that ** is filled with zeroes. A zeroblob uses a fixed amount of memory ** (just an integer to hold its size) while it is being processed. ** Zeroblobs are intended to serve as placeholders for BLOBs whose ** content is later written using ** [sqlite3_blob_open | incremental BLOB I/O] routines. ** A negative value for the zeroblob results in a zero-length BLOB. ** ** The sqlite3_bind_*() routines must be called after ** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and ** before [sqlite3_step()]. ** Bindings are not cleared by the [sqlite3_reset()] routine. ** Unbound parameters are interpreted as NULL. ** ** These routines return [SQLITE_OK] on success or an error code if ** anything goes wrong. [SQLITE_RANGE] is returned if the parameter ** index is out of range. [SQLITE_NOMEM] is returned if malloc() fails. ** [SQLITE_MISUSE] might be returned if these routines are called on a ** virtual machine that is the wrong state or which has already been finalized. ** Detection of misuse is unreliable. Applications should not depend ** on SQLITE_MISUSE returns. SQLITE_MISUSE is intended to indicate a ** a logic error in the application. Future versions of SQLite might ** panic rather than return SQLITE_MISUSE. ** ** See also: [sqlite3_bind_parameter_count()], ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13506} The [SQL statement compiler] recognizes tokens of the forms ** "?", "?NNN", "$VVV", ":VVV", and "@VVV" as SQL parameters, ** where NNN is any sequence of one or more digits ** and where VVV is any sequence of one or more alphanumeric ** characters or "::" optionally followed by a string containing ** no spaces and contained within parentheses. ** ** {F13509} The initial value of an SQL parameter is NULL. ** ** {F13512} The index of an "?" SQL parameter is one larger than the ** largest index of SQL parameter to the left, or 1 if ** the "?" is the leftmost SQL parameter. ** ** {F13515} The index of an "?NNN" SQL parameter is the integer NNN. ** ** {F13518} The index of an ":VVV", "$VVV", or "@VVV" SQL parameter is ** the same as the index of leftmost occurrences of the same ** parameter, or one more than the largest index over all ** parameters to the left if this is the first occurrence ** of this parameter, or 1 if this is the leftmost parameter. ** ** {F13521} The [SQL statement compiler] fails with an [SQLITE_RANGE] ** error if the index of an SQL parameter is less than 1 ** or greater than the compile-time SQLITE_MAX_VARIABLE_NUMBER ** parameter. ** ** {F13524} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,V,...)] ** associate the value V with all SQL parameters having an ** index of N in the [prepared statement] S. ** ** {F13527} Calls to [sqlite3_bind_text | sqlite3_bind(S,N,...)] ** override prior calls with the same values of S and N. ................................................................................ ** ** {F13530} Bindings established by [sqlite3_bind_text | sqlite3_bind(S,...)] ** persist across calls to [sqlite3_reset(S)]. ** ** {F13533} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds the first L ** bytes of the BLOB or string pointed to by V, when L ** is non-negative. ** ** {F13536} In calls to [sqlite3_bind_text(S,N,V,L,D)] or ** [sqlite3_bind_text16(S,N,V,L,D)] SQLite binds characters ** from V through the first zero character when L is negative. ** ** {F13539} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ................................................................................ ** constant [SQLITE_STATIC], SQLite assumes that the value V ** is held in static unmanaged space that will not change ** during the lifetime of the binding. ** ** {F13542} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] when D is the special ** constant [SQLITE_TRANSIENT], the routine makes a ** private copy of the value V before it returns. ** ** {F13545} In calls to [sqlite3_bind_blob(S,N,V,L,D)], ** [sqlite3_bind_text(S,N,V,L,D)], or ** [sqlite3_bind_text16(S,N,V,L,D)] when D is a pointer to ** a function, SQLite invokes that function to destroy the ** value V after it has finished using the value V. ** ** {F13548} In calls to [sqlite3_bind_zeroblob(S,N,V,L)] the value bound ** is a BLOB of L bytes, or a zero-length BLOB if L is negative. ** ** {F13551} In calls to [sqlite3_bind_value(S,N,V)] the V argument may ** be either a [protected sqlite3_value] object or an ** [unprotected sqlite3_value] object. */ int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); int sqlite3_bind_double(sqlite3_stmt*, int, double); ................................................................................ int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); /* ** CAPI3REF: Number Of SQL Parameters {F13600} ** ** This routine can be used to find the number of [SQL parameters] ** in a [prepared statement]. SQL parameters are tokens of the ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as ** placeholders for values that are [sqlite3_bind_blob | bound] ** to the parameters at a later time. ** ** This routine actually returns the index of the largest (rightmost) ** parameter. For all forms except ?NNN, this will correspond to the ** number of unique parameters. If parameters of the ?NNN are used, ** there may be gaps in the list. ** ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_name()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13601} The [sqlite3_bind_parameter_count(S)] interface returns ** the largest index of all SQL parameters in the ** [prepared statement] S, or 0 if S contains no SQL parameters. */ int sqlite3_bind_parameter_count(sqlite3_stmt*); /* ** CAPI3REF: Name Of A Host Parameter {F13620} ** ** This routine returns a pointer to the name of the n-th ** [SQL parameter] in a [prepared statement]. ** SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" ** respectively. ** In other words, the initial ":" or "$" or "@" or "?" ** is included as part of the name. ** Parameters of the form "?" without a following integer have no name ** and are also referred to as "anonymous parameters". ** ** The first host parameter has an index of 1, not 0. ** ** If the value n is out of range or if the n-th parameter is ** nameless, then NULL is returned. The returned string is ** always in UTF-8 encoding even if the named parameter was ** originally specified as UTF-16 in [sqlite3_prepare16()] or ** [sqlite3_prepare16_v2()]. ** ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13621} The [sqlite3_bind_parameter_name(S,N)] interface returns ** a UTF-8 rendering of the name of the SQL parameter in ** the [prepared statement] S having index N, or ** NULL if there is no SQL parameter with index N or if the ** parameter with index N is an anonymous parameter "?". */ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); /* ** CAPI3REF: Index Of A Parameter With A Given Name {F13640} ................................................................................ ** See also: [sqlite3_bind_blob|sqlite3_bind()], ** [sqlite3_bind_parameter_count()], and ** [sqlite3_bind_parameter_index()]. ** ** INVARIANTS: ** ** {F13641} The [sqlite3_bind_parameter_index(S,N)] interface returns ** the index of SQL parameter in the [prepared statement] ** S whose name matches the UTF-8 string N, or 0 if there is ** no match. */ int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); /* ** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660} ** ** Contrary to the intuition of many, [sqlite3_reset()] does not reset ** the [sqlite3_bind_blob | bindings] on a [prepared statement]. ** Use this routine to reset all host parameters to NULL. ** ** INVARIANTS: ** ** {F13661} The [sqlite3_clear_bindings(S)] interface resets all SQL ** parameter bindings in the [prepared statement] S back to NULL. */ int sqlite3_clear_bindings(sqlite3_stmt*); /* ** CAPI3REF: Number Of Columns In A Result Set {F13710} ** ** Return the number of columns in the result set returned by the ** [prepared statement]. This routine returns 0 if pStmt is an SQL ** statement that does not return data (for example an [UPDATE]). ** ** INVARIANTS: ** ** {F13711} The [sqlite3_column_count(S)] interface returns the number of ** columns in the result set generated by the [prepared statement] S, ** or 0 if S does not generate a result set. */ int sqlite3_column_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Column Names In A Result Set {F13720} ** ** These routines return the name assigned to a particular column ** in the result set of a [SELECT] statement. The sqlite3_column_name() ** interface returns a pointer to a zero-terminated UTF-8 string ** and sqlite3_column_name16() returns a pointer to a zero-terminated ** UTF-16 string. The first parameter is the [prepared statement] ** that implements the [SELECT] statement. The second parameter is the ** column number. The leftmost column is number 0. ** ** The returned string pointer is valid until either the [prepared statement] ** is destroyed by [sqlite3_finalize()] or until the next call to ** sqlite3_column_name() or sqlite3_column_name16() on the same column. ** ** If sqlite3_malloc() fails during the processing of either routine ** (for example during a conversion from UTF-8 to UTF-16) then a ** NULL pointer is returned. ** ** The name of a result column is the value of the "AS" clause for ** that column, if there is an AS clause. If there is no AS clause ** then the name of the column is unspecified and may change from ** one release of SQLite to the next. ** ** INVARIANTS: ** ** {F13721} A successful invocation of the [sqlite3_column_name(S,N)] ** interface returns the name of the Nth column (where 0 is ** the leftmost column) for the result set of the ** [prepared statement] S as a zero-terminated UTF-8 string. ** ** {F13723} A successful invocation of the [sqlite3_column_name16(S,N)] ** interface returns the name of the Nth column (where 0 is ** the leftmost column) for the result set of the ** [prepared statement] S as a zero-terminated UTF-16 string ** in the native byte order. ** ** {F13724} The [sqlite3_column_name()] and [sqlite3_column_name16()] ** interfaces return a NULL pointer if they are unable to ** allocate memory to hold their normal return strings. ** ** {F13725} If the N parameter to [sqlite3_column_name(S,N)] or ** [sqlite3_column_name16(S,N)] is out of range, then the ** interfaces return a NULL pointer. ** ** {F13726} The strings returned by [sqlite3_column_name(S,N)] and ** [sqlite3_column_name16(S,N)] are valid until the next ** call to either routine with the same S and N parameters ** or until [sqlite3_finalize(S)] is called. ** ** {F13727} When a result column of a [SELECT] statement contains ** an AS clause, the name of that column is the identifier ** to the right of the AS keyword. */ const char *sqlite3_column_name(sqlite3_stmt*, int N); const void *sqlite3_column_name16(sqlite3_stmt*, int N); /* ** CAPI3REF: Source Of Data In A Query Result {F13740} ** ** These routines provide a means to determine what column of what ** table in which database a result of a [SELECT] statement comes from. ** The name of the database or table or column can be returned as ** either a UTF-8 or UTF-16 string. The _database_ routines return ** the database name, the _table_ routines return the table name, and ** the origin_ routines return the column name. ** The returned string is valid until the [prepared statement] is destroyed ** using [sqlite3_finalize()] or until the same information is requested ** again in a different encoding. ** ** The names returned are the original un-aliased names of the ** database, table, and column. ** ** The first argument to the following calls is a [prepared statement]. ** These functions return information about the Nth column returned by ** the statement, where N is the second function argument. ** ** If the Nth column returned by the statement is an expression or ** subquery and is not a column value, then all of these functions return ** NULL. These routine might also return NULL if a memory allocation error ** occurs. Otherwise, they return the name of the attached database, table ** and column that query result column was extracted from. ** ** As with all other SQLite APIs, those postfixed with "16" return ** UTF-16 encoded strings, the other functions return UTF-8. {END} ** ** These APIs are only available if the library was compiled with the ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. ** ** {A13751} ** If two or more threads call one or more of these routines against the same ** prepared statement and column at the same time then the results are ** undefined. ** ** INVARIANTS: ** ** {F13741} The [sqlite3_column_database_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the database from which the ** Nth result column of the [prepared statement] S is extracted, ** or NULL if the Nth column of S is a general expression ** or if unable to allocate memory to store the name. ** ** {F13742} The [sqlite3_column_database_name16(S,N)] interface returns either ** the UTF-16 native byte order zero-terminated name of the database ** from which the Nth result column of the [prepared statement] S is ** extracted, or NULL if the Nth column of S is a general expression ** or if unable to allocate memory to store the name. ** ** {F13743} The [sqlite3_column_table_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the table from which the ** Nth result column of the [prepared statement] S is extracted, ** or NULL if the Nth column of S is a general expression ** or if unable to allocate memory to store the name. ** ** {F13744} The [sqlite3_column_table_name16(S,N)] interface returns either ** the UTF-16 native byte order zero-terminated name of the table ** from which the Nth result column of the [prepared statement] S is ** extracted, or NULL if the Nth column of S is a general expression ** or if unable to allocate memory to store the name. ** ** {F13745} The [sqlite3_column_origin_name(S,N)] interface returns either ** the UTF-8 zero-terminated name of the table column from which the ** Nth result column of the [prepared statement] S is extracted, ** or NULL if the Nth column of S is a general expression ** or if unable to allocate memory to store the name. ** ** {F13746} The [sqlite3_column_origin_name16(S,N)] interface returns either ** the UTF-16 native byte order zero-terminated name of the table ** column from which the Nth result column of the ** [prepared statement] S is extracted, or NULL if the Nth column ** of S is a general expression or if unable to allocate memory ** to store the name. ** ** {F13748} The return values from ** [sqlite3_column_database_name | column metadata interfaces] ** are valid for the lifetime of the [prepared statement] ** or until the encoding is changed by another metadata ** interface call for the same prepared statement and column. ** ** LIMITATIONS: ** ** {A13751} If two or more threads call one or more ** [sqlite3_column_database_name | column metadata interfaces] ** for the same [prepared statement] and result column ** at the same time then the results are undefined. */ const char *sqlite3_column_database_name(sqlite3_stmt*,int); const void *sqlite3_column_database_name16(sqlite3_stmt*,int); const char *sqlite3_column_table_name(sqlite3_stmt*,int); const void *sqlite3_column_table_name16(sqlite3_stmt*,int); const char *sqlite3_column_origin_name(sqlite3_stmt*,int); const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); /* ** CAPI3REF: Declared Datatype Of A Query Result {F13760} ** ** The first parameter is a [prepared statement]. ** If this statement is a [SELECT] statement and the Nth column of the ** returned result set of that [SELECT] is a table column (not an ** expression or subquery) then the declared type of the table ** column is returned. If the Nth column of the result set is an ** expression or subquery, then a NULL pointer is returned. ** The returned string is always UTF-8 encoded. {END} ** ** For example, given the database schema: ** ** CREATE TABLE t1(c1 VARIANT); ** ** and the following statement to be compiled: ** ** SELECT c1 + 1, c1 FROM t1; ** ** this routine would return the string "VARIANT" for the second result ** column (i==1), and a NULL pointer for the first result column (i==0). ** ** SQLite uses dynamic run-time typing. So just because a column ** is declared to contain a particular type does not mean that the ** data stored in that column is of the declared type. SQLite is ** strongly typed, but the typing is dynamic not static. Type ** is associated with individual values, not with the containers ** used to hold those values. ** ** INVARIANTS: ** ** {F13761} A successful call to [sqlite3_column_decltype(S,N)] returns a ** zero-terminated UTF-8 string containing the declared datatype ** of the table column that appears as the Nth column (numbered ** from 0) of the result set to the [prepared statement] S. ** ** {F13762} A successful call to [sqlite3_column_decltype16(S,N)] ** returns a zero-terminated UTF-16 native byte order string ** containing the declared datatype of the table column that appears ** as the Nth column (numbered from 0) of the result set to the ** [prepared statement] S. ** ** {F13763} If N is less than 0 or N is greater than or equal to ** the number of columns in the [prepared statement] S, ** or if the Nth column of S is an expression or subquery rather ** than a table column, or if a memory allocation failure ** occurs during encoding conversions, then ** calls to [sqlite3_column_decltype(S,N)] or ** [sqlite3_column_decltype16(S,N)] return NULL. */ const char *sqlite3_column_decltype(sqlite3_stmt*,int); const void *sqlite3_column_decltype16(sqlite3_stmt*,int); /* ** CAPI3REF: Evaluate An SQL Statement {F13200} ** ** After a [prepared statement] has been prepared using either ** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function ** must be called one or more times to evaluate the statement. ** ** The details of the behavior of the sqlite3_step() interface depend ** on whether the statement was prepared using the newer "v2" interface ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy ** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the ** new "v2" interface is recommended for new applications but the legacy ** interface will continue to be supported. ** ** In the legacy interface, the return value will be either [SQLITE_BUSY], ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. ** With the "v2" interface, any of the other [result codes] or ** [extended result codes] might be returned as well. ** ** [SQLITE_BUSY] means that the database engine was unable to acquire the ** database locks it needs to do its job. If the statement is a [COMMIT] ** or occurs outside of an explicit transaction, then you can retry the ** statement. If the statement is not a [COMMIT] and occurs within a ** explicit transaction then you should rollback the transaction before ** continuing. ** ** [SQLITE_DONE] means that the statement has finished executing ** successfully. sqlite3_step() should not be called again on this virtual ** machine without first calling [sqlite3_reset()] to reset the virtual ** machine back to its initial state. ** ** If the SQL statement being executed returns any data, then [SQLITE_ROW] ** is returned each time a new row of data is ready for processing by the ** caller. The values may be accessed using the [column access functions]. ** sqlite3_step() is called again to retrieve the next row of data. ** ** [SQLITE_ERROR] means that a run-time error (such as a constraint ** violation) has occurred. sqlite3_step() should not be called again on ** the VM. More information may be found by calling [sqlite3_errmsg()]. ** With the legacy interface, a more specific error code (for example, ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) ** can be obtained by calling [sqlite3_reset()] on the ** [prepared statement]. In the "v2" interface, ** the more specific error code is returned directly by sqlite3_step(). ** ** [SQLITE_MISUSE] means that the this routine was called inappropriately. ** Perhaps it was called on a [prepared statement] that has ** already been [sqlite3_finalize | finalized] or on one that had ** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could ** be the case that the same database connection is being used by two or ** more threads at the same moment in time. ** ** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step() ** API always returns a generic error code, [SQLITE_ERROR], following any ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call ** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the ** specific [error codes] that better describes the error. ** We admit that this is a goofy design. The problem has been fixed ** with the "v2" interface. If you prepare all of your SQL statements ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, ** then the more specific [error codes] are returned directly ** by sqlite3_step(). The use of the "v2" interface is recommended. ** ** INVARIANTS: ** ** {F13202} If the [prepared statement] S is ready to be run, then ** [sqlite3_step(S)] advances that prepared statement until ** completion or until it is ready to return another row of the ** result set, or until an [sqlite3_interrupt | interrupt] ** or a run-time error occurs. ** ** {F15304} When a call to [sqlite3_step(S)] causes the [prepared statement] ** S to run to completion, the function returns [SQLITE_DONE]. ** ** {F15306} When a call to [sqlite3_step(S)] stops because it is ready to ** return another row of the result set, it returns [SQLITE_ROW]. ** ** {F15308} If a call to [sqlite3_step(S)] encounters an ** [sqlite3_interrupt | interrupt] or a run-time error, ** it returns an appropriate error code that is not one of ** [SQLITE_OK], [SQLITE_ROW], or [SQLITE_DONE]. ** ** {F15310} If an [sqlite3_interrupt | interrupt] or a run-time error ** occurs during a call to [sqlite3_step(S)] ** for a [prepared statement] S created using ** legacy interfaces [sqlite3_prepare()] or ** [sqlite3_prepare16()], then the function returns either ** [SQLITE_ERROR], [SQLITE_BUSY], or [SQLITE_MISUSE]. */ int sqlite3_step(sqlite3_stmt*); /* ** CAPI3REF: Number of columns in a result set {F13770} ** ** Returns the number of values in the current row of the result set. ** ** INVARIANTS: ** ** {F13771} After a call to [sqlite3_step(S)] that returns [SQLITE_ROW], ** the [sqlite3_data_count(S)] routine will return the same value ** as the [sqlite3_column_count(S)] function. ** ** {F13772} After [sqlite3_step(S)] has returned any value other than ** [SQLITE_ROW] or before [sqlite3_step(S)] has been called on the ** [prepared statement] for the first time since it was ** [sqlite3_prepare | prepared] or [sqlite3_reset | reset], ** the [sqlite3_data_count(S)] routine returns zero. */ int sqlite3_data_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Fundamental Datatypes {F10265} ** KEYWORDS: SQLITE_TEXT ** ** {F10266} Every value in SQLite has one of five fundamental datatypes: ** ** <ul> ** <li> 64-bit signed integer ** <li> 64-bit IEEE floating point number ** <li> string ** <li> BLOB ** <li> NULL ** </ul> {END} ** ** These constants are codes for each of those types. ** ** Note that the SQLITE_TEXT constant was also used in SQLite version 2 ** for a completely different meaning. Software that links against both ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not ** SQLITE_TEXT. */ #define SQLITE_INTEGER 1 #define SQLITE_FLOAT 2 #define SQLITE_BLOB 4 #define SQLITE_NULL 5 #ifdef SQLITE_TEXT ................................................................................ # undef SQLITE_TEXT #else # define SQLITE_TEXT 3 #endif #define SQLITE3_TEXT 3 /* ** CAPI3REF: Result Values From A Query {F13800} ** KEYWORDS: {column access functions} ** ** These routines form the "result set query" interface. ** ** These routines return information about a single column of the current ** result row of a query. In every case the first argument is a pointer ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] ** that was returned from [sqlite3_prepare_v2()] or one of its variants) ** and the second argument is the index of the column for which information ** should be returned. The leftmost column of the result set has the index 0. ** ** If the SQL statement does not currently point to a valid row, or if the ** column index is out of range, the result is undefined. ** These routines may only be called when the most recent call to ** [sqlite3_step()] has returned [SQLITE_ROW] and neither ** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. ** If any of these routines are called after [sqlite3_reset()] or ** [sqlite3_finalize()] or after [sqlite3_step()] has returned ** something other than [SQLITE_ROW], the results are undefined. ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] ** are called from a different thread while any of these routines ** are pending, then the results are undefined. ** ** The sqlite3_column_type() routine returns the ** [SQLITE_INTEGER | datatype code] for the initial data type ** of the result column. The returned value is one of [SQLITE_INTEGER], ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value ** returned by sqlite3_column_type() is only meaningful if no type ** conversions have occurred as described below. After a type conversion, ** the value returned by sqlite3_column_type() is undefined. Future ** versions of SQLite may change the behavior of sqlite3_column_type() ** following a type conversion. ** ** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() ** routine returns the number of bytes in that BLOB or string. ** If the result is a UTF-16 string, then sqlite3_column_bytes() converts ** the string to UTF-8 and then returns the number of bytes. ** If the result is a numeric value then sqlite3_column_bytes() uses ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns ** the number of bytes in that string. ** The value returned does not include the zero terminator at the end ** of the string. For clarity: the value returned is the number of ** bytes in the string, not the number of characters. ** ** Strings returned by sqlite3_column_text() and sqlite3_column_text16(), ** even empty strings, are always zero terminated. The return ** value from sqlite3_column_blob() for a zero-length BLOB is an arbitrary ** pointer, possibly even a NULL pointer. ** ** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() ** but leaves the result in UTF-16 in native byte order instead of UTF-8. ** The zero terminator is not included in this count. ** ** The object returned by [sqlite3_column_value()] is an ** [unprotected sqlite3_value] object. An unprotected sqlite3_value object ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. ** If the [unprotected sqlite3_value] object returned by ** [sqlite3_column_value()] is used in any other way, including calls ** to routines like [sqlite3_value_int()], [sqlite3_value_text()], ** or [sqlite3_value_bytes()], then the behavior is undefined. ** ** These routines attempt to convert the value where appropriate. For ** example, if the internal representation is FLOAT and a text result ** is requested, [sqlite3_snprintf()] is used internally to perform the ** conversion automatically. The following table details the conversions ** that are applied: ** ** <blockquote> ** <table border="1"> ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion ** ** <tr><td> NULL <td> INTEGER <td> Result is 0 ** <tr><td> NULL <td> FLOAT <td> Result is 0.0 ** <tr><td> NULL <td> TEXT <td> Result is NULL pointer ** <tr><td> NULL <td> BLOB <td> Result is NULL pointer ** <tr><td> INTEGER <td> FLOAT <td> Convert from integer to float ** <tr><td> INTEGER <td> TEXT <td> ASCII rendering of the integer ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT ** <tr><td> FLOAT <td> INTEGER <td> Convert from float to integer ** <tr><td> FLOAT <td> TEXT <td> ASCII rendering of the float ** <tr><td> FLOAT <td> BLOB <td> Same as FLOAT->TEXT ** <tr><td> TEXT <td> INTEGER <td> Use atoi() ** <tr><td> TEXT <td> FLOAT <td> Use atof() ** <tr><td> TEXT <td> BLOB <td> No change ** <tr><td> BLOB <td> INTEGER <td> Convert to TEXT then use atoi() ................................................................................ ** <tr><td> BLOB <td> FLOAT <td> Convert to TEXT then use atof() ** <tr><td> BLOB <td> TEXT <td> Add a zero terminator if needed ** </table> ** </blockquote> ** ** The table above makes reference to standard C library functions atoi() ** and atof(). SQLite does not really use these functions. It has its ** own equivalent internal routines. The atoi() and atof() names are ** used in the table for brevity and because they are familiar to most ** C programmers. ** ** Note that when type conversions occur, pointers returned by prior ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or ** sqlite3_column_text16() may be invalidated. ** Type conversions and pointer invalidations might occur ** in the following cases: ** ** <ul> ** <li> The initial content is a BLOB and sqlite3_column_text() or ** sqlite3_column_text16() is called. A zero-terminator might ** need to be added to the string.</li> ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or ** sqlite3_column_text16() is called. The content must be converted ** to UTF-16.</li> ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or ** sqlite3_column_text() is called. The content must be converted ** to UTF-8.</li> ** </ul> ** ** Conversions between UTF-16be and UTF-16le are always done in place and do ** not invalidate a prior pointer, though of course the content of the buffer ** that the prior pointer points to will have been modified. Other kinds ** of conversion are done in place when it is possible, but sometimes they ** are not possible and in those cases prior pointers are invalidated. ** ** The safest and easiest to remember policy is to invoke these routines ** in one of the following ways: ** ** <ul> ** <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li> ** <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li> ** <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li> ** </ul> ** ** In other words, you should call sqlite3_column_text(), ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result ** into the desired format, then invoke sqlite3_column_bytes() or ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls ** to sqlite3_column_text() or sqlite3_column_blob() with calls to ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() ** with calls to sqlite3_column_bytes(). ** ** The pointers returned are valid until a type conversion occurs as ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or ** [sqlite3_finalize()] is called. The memory space used to hold strings ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into ** [sqlite3_free()]. ** ** If a memory allocation error occurs during the evaluation of any ** of these routines, a default value is returned. The default value ** is either the integer 0, the floating point number 0.0, or a NULL ** pointer. Subsequent calls to [sqlite3_errcode()] will return ** [SQLITE_NOMEM]. ** ** INVARIANTS: ** ** {F13803} The [sqlite3_column_blob(S,N)] interface converts the ** Nth column in the current row of the result set for ** the [prepared statement] S into a BLOB and then returns a ** pointer to the converted value. ** ** {F13806} The [sqlite3_column_bytes(S,N)] interface returns the ** number of bytes in the BLOB or string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_column_blob(S,N)] or ** [sqlite3_column_text(S,N)]. ** ** {F13809} The [sqlite3_column_bytes16(S,N)] interface returns the ** number of bytes in the string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_column_text16(S,N)]. ** ** {F13812} The [sqlite3_column_double(S,N)] interface converts the ** Nth column in the current row of the result set for the ** [prepared statement] S into a floating point value and ** returns a copy of that value. ** ** {F13815} The [sqlite3_column_int(S,N)] interface converts the ** Nth column in the current row of the result set for the ** [prepared statement] S into a 64-bit signed integer and ** returns the lower 32 bits of that integer. ** ** {F13818} The [sqlite3_column_int64(S,N)] interface converts the ** Nth column in the current row of the result set for the ** [prepared statement] S into a 64-bit signed integer and ** returns a copy of that integer. ** ** {F13821} The [sqlite3_column_text(S,N)] interface converts the ** Nth column in the current row of the result set for ** the [prepared statement] S into a zero-terminated UTF-8 ** string and returns a pointer to that string. ** ** {F13824} The [sqlite3_column_text16(S,N)] interface converts the ** Nth column in the current row of the result set for the ** [prepared statement] S into a zero-terminated 2-byte ** aligned UTF-16 native byte order string and returns ** a pointer to that string. ** ** {F13827} The [sqlite3_column_type(S,N)] interface returns ** one of [SQLITE_NULL], [SQLITE_INTEGER], [SQLITE_FLOAT], ** [SQLITE_TEXT], or [SQLITE_BLOB] as appropriate for ** the Nth column in the current row of the result set for ** the [prepared statement] S. ** ** {F13830} The [sqlite3_column_value(S,N)] interface returns a ** pointer to an [unprotected sqlite3_value] object for the ** Nth column in the current row of the result set for ** the [prepared statement] S. */ const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); int sqlite3_column_bytes(sqlite3_stmt*, int iCol); int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); double sqlite3_column_double(sqlite3_stmt*, int iCol); int sqlite3_column_int(sqlite3_stmt*, int iCol); sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); ................................................................................ const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); /* ** CAPI3REF: Destroy A Prepared Statement Object {F13300} ** ** The sqlite3_finalize() function is called to delete a [prepared statement]. ** If the statement was executed successfully or not executed at all, then ** SQLITE_OK is returned. If execution of the statement failed then an ** [error code] or [extended error code] is returned. ** ** This routine can be called at any point during the execution of the ** [prepared statement]. If the virtual machine has not ** completed execution when this routine is called, that is like ** encountering an error or an [sqlite3_interrupt | interrupt]. ** Incomplete updates may be rolled back and transactions canceled, ** depending on the circumstances, and the ** [error code] returned will be [SQLITE_ABORT]. ** ** INVARIANTS: ** ** {F11302} The [sqlite3_finalize(S)] interface destroys the ** [prepared statement] S and releases all ** memory and file resources held by that object. ................................................................................ ** then [sqlite3_finalize(S)] returns that same error. */ int sqlite3_finalize(sqlite3_stmt *pStmt); /* ** CAPI3REF: Reset A Prepared Statement Object {F13330} ** ** The sqlite3_reset() function is called to reset a [prepared statement] ** object back to its initial state, ready to be re-executed. ** Any SQL statement variables that had values bound to them using ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. ** Use [sqlite3_clear_bindings()] to reset the bindings. ** ** {F11332} The [sqlite3_reset(S)] interface resets the [prepared statement] S ** back to the beginning of its program. ** ** {F11334} If the most recent call to [sqlite3_step(S)] for the ** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], ** or if [sqlite3_step(S)] has never before been called on S, ** then [sqlite3_reset(S)] returns [SQLITE_OK]. ** ** {F11336} If the most recent call to [sqlite3_step(S)] for the ** [prepared statement] S indicated an error, then ** [sqlite3_reset(S)] returns an appropriate [error code]. ** ** {F11338} The [sqlite3_reset(S)] interface does not change the values ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. */ int sqlite3_reset(sqlite3_stmt *pStmt); /* ** CAPI3REF: Create Or Redefine SQL Functions {F16100} ** KEYWORDS: {function creation routines} ** KEYWORDS: {application-defined SQL function} ** KEYWORDS: {application-defined SQL functions} ** ** These two functions (collectively known as "function creation routines") ** are used to add SQL functions or aggregates or to redefine the behavior ** of existing SQL functions or aggregates. The only difference between the ** two is that the second parameter, the name of the (scalar) function or ** aggregate, is encoded in UTF-8 for sqlite3_create_function() and UTF-16 ** for sqlite3_create_function16(). ** ** The first parameter is the [database connection] to which the SQL ** function is to be added. If a single program uses more than one database ** connection internally, then SQL functions must be added individually to ** each database connection. ** ** The second parameter is the name of the SQL function to be created or ** redefined. The length of the name is limited to 255 bytes, exclusive of ** the zero-terminator. Note that the name length limit is in bytes, not ** characters. Any attempt to create a function with a longer name ** will result in [SQLITE_ERROR] being returned. ** ** The third parameter is the number of arguments that the SQL function or ** aggregate takes. If this parameter is negative, then the SQL function or ** aggregate may take any number of arguments. ** ** The fourth parameter, eTextRep, specifies what ** [SQLITE_UTF8 | text encoding] this SQL function prefers for ** its parameters. Any SQL function implementation should be able to work ** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be ** more efficient with one encoding than another. It is allowed to ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple ** times with the same function but with different values of eTextRep. ** When multiple implementations of the same function are available, SQLite ** will pick the one that involves the least amount of data conversion. ** If there is only a single implementation which does not care what text ** encoding is used, then the fourth argument should be [SQLITE_ANY]. ** ** The fifth parameter is an arbitrary pointer. The implementation of the ** function can gain access to this pointer using [sqlite3_user_data()]. ** ** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are ** pointers to C-language functions that implement the SQL function or ** aggregate. A scalar SQL function requires an implementation of the xFunc ** callback only, NULL pointers should be passed as the xStep and xFinal ** parameters. An aggregate SQL function requires an implementation of xStep ** and xFinal and NULL should be passed for xFunc. To delete an existing ** SQL function or aggregate, pass NULL for all three function callbacks. ** ** It is permitted to register multiple implementations of the same ** functions with the same name but with either differing numbers of ** arguments or differing preferred text encodings. SQLite will use ** the implementation most closely matches the way in which the ** SQL function is used. ** ** INVARIANTS: ** ** {F16103} The [sqlite3_create_function16()] interface behaves exactly ** like [sqlite3_create_function()] in every way except that it ** interprets the zFunctionName argument as zero-terminated UTF-16 ** native byte order instead of as zero-terminated UTF-8. ** ** {F16106} A successful invocation of ** the [sqlite3_create_function(D,X,N,E,...)] interface registers ** or replaces callback functions in the [database connection] D ** used to implement the SQL function named X with N parameters ** and having a preferred text encoding of E. ** ** {F16109} A successful call to [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** replaces the P, F, S, and L values from any prior calls with ** the same D, X, N, and E values. ** ** {F16112} The [sqlite3_create_function(D,X,...)] interface fails with ** a return code of [SQLITE_ERROR] if the SQL function name X is ................................................................................ ** {F16136} When calls to [sqlite3_create_function(D,X,N,E,...)] ** specify multiple implementations of the same function X with ** the same number of arguments N but with different ** encodings E, then the implementation where E matches the ** database encoding is preferred. ** ** {F16139} For an aggregate SQL function created using ** [sqlite3_create_function(D,X,N,E,P,0,S,L)] the finalizer ** function L will always be invoked exactly once if the ** step function S is called one or more times. ** ** {F16142} When SQLite invokes either the xFunc or xStep function of ** an application-defined SQL function or aggregate created ** by [sqlite3_create_function()] or [sqlite3_create_function16()], ** then the array of [sqlite3_value] objects passed as the ................................................................................ ** each parameter to the SQL function. These routines are used to ** extract values from the [sqlite3_value] objects. ** ** These routines work only with [protected sqlite3_value] objects. ** Any attempt to use these routines on an [unprotected sqlite3_value] ** object results in undefined behavior. ** ** These routines work just like the corresponding [column access functions] ** except that these routines take a single [protected sqlite3_value] object ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. ** ** The sqlite3_value_text16() interface extracts a UTF-16 string ** in the native byte-order of the host machine. The ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces ** extract UTF-16 strings as big-endian and little-endian respectively. ** ** The sqlite3_value_numeric_type() interface attempts to apply ** numeric affinity to the value. This means that an attempt is ** made to convert the value to an integer or floating point. If ** such a conversion is possible without loss of information (in other ** words, if the value is a string that looks like a number) ** then the conversion is performed. Otherwise no conversion occurs. ** The [SQLITE_INTEGER | datatype] after conversion is returned. ** ** Please pay particular attention to the fact that the pointer returned ** from [sqlite3_value_blob()], [sqlite3_value_text()], or ** [sqlite3_value_text16()] can be invalidated by a subsequent call to ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], ** or [sqlite3_value_text16()]. ** ** These routines must be called from the same thread as ** the SQL function that supplied the [sqlite3_value*] parameters. ** ** INVARIANTS: ** ** {F15103} The [sqlite3_value_blob(V)] interface converts the ** [protected sqlite3_value] object V into a BLOB and then ** returns a pointer to the converted value. ** ** {F15106} The [sqlite3_value_bytes(V)] interface returns the ** number of bytes in the BLOB or string (exclusive of the ** zero terminator on the string) that was returned by the ** most recent call to [sqlite3_value_blob(V)] or ** [sqlite3_value_text(V)]. ** ** {F15109} The [sqlite3_value_bytes16(V)] interface returns the ** number of bytes in the string (exclusive of the ** zero terminator on the string) that was returned by the ................................................................................ ** returns the lower 32 bits of that integer. ** ** {F15118} The [sqlite3_value_int64(V)] interface converts the ** [protected sqlite3_value] object V into a 64-bit signed integer and ** returns a copy of that integer. ** ** {F15121} The [sqlite3_value_text(V)] interface converts the ** [protected sqlite3_value] object V into a zero-terminated UTF-8 ** string and returns a pointer to that string. ** ** {F15124} The [sqlite3_value_text16(V)] interface converts the ** [protected sqlite3_value] object V into a zero-terminated 2-byte ** aligned UTF-16 native byte order ** string and returns a pointer to that string. ** ................................................................................ ** the [sqlite3_value] object V. ** ** {F15136} The [sqlite3_value_numeric_type(V)] interface converts ** the [protected sqlite3_value] object V into either an integer or ** a floating point value if it can do so without loss of ** information, and returns one of [SQLITE_NULL], ** [SQLITE_INTEGER], [SQLITE_FLOAT], [SQLITE_TEXT], or ** [SQLITE_BLOB] as appropriate for the ** [protected sqlite3_value] object V after the conversion attempt. */ const void *sqlite3_value_blob(sqlite3_value*); int sqlite3_value_bytes(sqlite3_value*); int sqlite3_value_bytes16(sqlite3_value*); double sqlite3_value_double(sqlite3_value*); int sqlite3_value_int(sqlite3_value*); sqlite3_int64 sqlite3_value_int64(sqlite3_value*); ................................................................................ int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); /* ** CAPI3REF: Obtain Aggregate Function Context {F16210} ** ** The implementation of aggregate SQL functions use this routine to allocate ** a structure for storing their state. ** ** The first time the sqlite3_aggregate_context() routine is called for a ** particular aggregate, SQLite allocates nBytes of memory, zeroes out that ** memory, and returns a pointer to it. On second and subsequent calls to ** sqlite3_aggregate_context() for the same aggregate function index, ** the same buffer is returned. The implementation of the aggregate can use ** the returned buffer to accumulate data. ** ** SQLite automatically frees the allocated buffer when the aggregate ** query concludes. ** ** The first parameter should be a copy of the ** [sqlite3_context | SQL function context] that is the first parameter ** to the callback routine that implements the aggregate function. ** ** This routine must be called from the same thread in which ** the aggregate SQL function is running. ** ** INVARIANTS: ** ** {F16211} The first invocation of [sqlite3_aggregate_context(C,N)] for ** a particular instance of an aggregate function (for a particular ** context C) causes SQLite to allocate N bytes of memory, ** zero that memory, and return a pointer to the allocated memory. ** ** {F16213} If a memory allocation error occurs during ** [sqlite3_aggregate_context(C,N)] then the function returns 0. ** ** {F16215} Second and subsequent invocations of ** [sqlite3_aggregate_context(C,N)] for the same context pointer C ** ignore the N parameter and return a pointer to the same ................................................................................ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); /* ** CAPI3REF: User Data For Functions {F16240} ** ** The sqlite3_user_data() interface returns a copy of ** the pointer that was the pUserData parameter (the 5th parameter) ** of the [sqlite3_create_function()] ** and [sqlite3_create_function16()] routines that originally ** registered the application defined function. {END} ** ** This routine must be called from the same thread in which ** the application-defined function is running. ** ** INVARIANTS: ** ** {F16243} The [sqlite3_user_data(C)] interface returns a copy of the ** P pointer from the [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** or [sqlite3_create_function16(D,X,N,E,P,F,S,L)] call that ** registered the SQL function associated with [sqlite3_context] C. */ void *sqlite3_user_data(sqlite3_context*); /* ** CAPI3REF: Database Connection For Functions {F16250} ** ** The sqlite3_context_db_handle() interface returns a copy of ** the pointer to the [database connection] (the 1st parameter) ** of the [sqlite3_create_function()] ** and [sqlite3_create_function16()] routines that originally ** registered the application defined function. ** ** INVARIANTS: ** ** {F16253} The [sqlite3_context_db_handle(C)] interface returns a copy of the ** D pointer from the [sqlite3_create_function(D,X,N,E,P,F,S,L)] ** or [sqlite3_create_function16(D,X,N,E,P,F,S,L)] call that ** registered the SQL function associated with [sqlite3_context] C. */ sqlite3 *sqlite3_context_db_handle(sqlite3_context*); /* ** CAPI3REF: Function Auxiliary Data {F16270} ** ** The following two functions may be used by scalar SQL functions to ** associate metadata with argument values. If the same value is passed to ** multiple invocations of the same SQL function during query execution, under ** some circumstances the associated metadata may be preserved. This may ** be used, for example, to add a regular-expression matching scalar ** function. The compiled version of the regular expression is stored as ** metadata associated with the SQL value passed as the regular expression ** pattern. The compiled regular expression can be reused on multiple ** invocations of the same function so that the original pattern string ** does not need to be recompiled on each invocation. ** ** The sqlite3_get_auxdata() interface returns a pointer to the metadata ** associated by the sqlite3_set_auxdata() function with the Nth argument ** value to the application-defined function. If no metadata has been ever ** been set for the Nth argument of the function, or if the corresponding ** function parameter has changed since the meta-data was set, ** then sqlite3_get_auxdata() returns a NULL pointer. ** ** The sqlite3_set_auxdata() interface saves the metadata ** pointed to by its 3rd parameter as the metadata for the N-th ** argument of the application-defined function. Subsequent ** calls to sqlite3_get_auxdata() might return this data, if it has ** not been destroyed. ** If it is not NULL, SQLite will invoke the destructor ** function given by the 4th parameter to sqlite3_set_auxdata() on ** the metadata when the corresponding function parameter changes ** or when the SQL statement completes, whichever comes first. ** ** SQLite is free to call the destructor and drop metadata on any ** parameter of any function at any time. The only guarantee is that ** the destructor will be called before the metadata is dropped. ** ** In practice, metadata is preserved between function calls for ** expressions that are constant at compile time. This includes literal ** values and SQL variables. ** ** These routines must be called from the same thread in which ** the SQL function is running. ** ** INVARIANTS: ................................................................................ ** ** {F16272} The [sqlite3_get_auxdata(C,N)] interface returns a pointer ** to metadata associated with the Nth parameter of the SQL function ** whose context is C, or NULL if there is no metadata associated ** with that parameter. ** ** {F16274} The [sqlite3_set_auxdata(C,N,P,D)] interface assigns a metadata ** pointer P to the Nth parameter of the SQL function with context C. ** ** {F16276} SQLite will invoke the destructor D with a single argument ** which is the metadata pointer P following a call to ** [sqlite3_set_auxdata(C,N,P,D)] when SQLite ceases to hold ** the metadata. ** ** {F16277} SQLite ceases to hold metadata for an SQL function parameter ................................................................................ void *sqlite3_get_auxdata(sqlite3_context*, int N); void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); /* ** CAPI3REF: Constants Defining Special Destructor Behavior {F10280} ** ** These are special values for the destructor that is passed in as the ** final argument to routines like [sqlite3_result_blob()]. If the destructor ** argument is SQLITE_STATIC, it means that the content pointer is constant ** and will never change. It does not need to be destroyed. The ** SQLITE_TRANSIENT value means that the content will likely change in ** the near future and that SQLite should make its own private copy of ** the content before returning. ** ** The typedef is necessary to work around problems in certain ** C++ compilers. See ticket #2191. */ ................................................................................ ** CAPI3REF: Setting The Result Of An SQL Function {F16400} ** ** These routines are used by the xFunc or xFinal callbacks that ** implement SQL functions and aggregates. See ** [sqlite3_create_function()] and [sqlite3_create_function16()] ** for additional information. ** ** These functions work very much like the [parameter binding] family of ** functions used to bind values to host parameters in prepared statements. ** Refer to the [SQL parameter] documentation for additional information. ** ** The sqlite3_result_blob() interface sets the result from ** an application-defined function to be the BLOB whose content is pointed ** to by the second parameter and which is N bytes long where N is the ** third parameter. ** ** The sqlite3_result_zeroblob() interfaces set the result of ** the application-defined function to be a BLOB containing all zero ** bytes and N bytes in size, where N is the value of the 2nd parameter. ** ** The sqlite3_result_double() interface sets the result from ** an application-defined function to be a floating point value specified ** by its 2nd argument. ** ** The sqlite3_result_error() and sqlite3_result_error16() functions ** cause the implemented SQL function to throw an exception. ** SQLite uses the string pointed to by the ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() ** as the text of an error message. SQLite interprets the error ** message string from sqlite3_result_error() as UTF-8. SQLite ** interprets the string from sqlite3_result_error16() as UTF-16 in native ** byte order. If the third parameter to sqlite3_result_error() ** or sqlite3_result_error16() is negative then SQLite takes as the error ** message all text up through the first zero character. ** If the third parameter to sqlite3_result_error() or ** sqlite3_result_error16() is non-negative then SQLite takes that many ** bytes (not characters) from the 2nd parameter as the error message. ** The sqlite3_result_error() and sqlite3_result_error16() ** routines make a private copy of the error message text before ** they return. Hence, the calling function can deallocate or ** modify the text after they return without harm. ** The sqlite3_result_error_code() function changes the error code ** returned by SQLite as a result of an error in a function. By default, ** the error code is SQLITE_ERROR. A subsequent call to sqlite3_result_error() ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. ** ** The sqlite3_result_toobig() interface causes SQLite to throw an error ** indicating that a string or BLOB is to long to represent. ** ** The sqlite3_result_nomem() interface causes SQLite to throw an error ** indicating that a memory allocation failed. ** ** The sqlite3_result_int() interface sets the return value ** of the application-defined function to be the 32-bit signed integer ** value given in the 2nd argument. ** The sqlite3_result_int64() interface sets the return value ** of the application-defined function to be the 64-bit signed integer ** value given in the 2nd argument. ** ** The sqlite3_result_null() interface sets the return value ** of the application-defined function to be NULL. ** ** The sqlite3_result_text(), sqlite3_result_text16(), ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces ** set the return value of the application-defined function to be ** a text string which is represented as UTF-8, UTF-16 native byte order, ** UTF-16 little endian, or UTF-16 big endian, respectively. ** SQLite takes the text result from the application from ** the 2nd parameter of the sqlite3_result_text* interfaces. ** If the 3rd parameter to the sqlite3_result_text* interfaces ** is negative, then SQLite takes result text from the 2nd parameter ** through the first zero character. ** If the 3rd parameter to the sqlite3_result_text* interfaces ** is non-negative, then as many bytes (not characters) of the text ** pointed to by the 2nd parameter are taken as the appl |