Documentation Source Text

set rowbody {}     ;# Content of a row
set rowtag {}      ;# 
unset -nocomplain keyword

# End a table row or the complete table.
#
proc endrow {} {
  global inrow body rowbody rowtag keyword dflt_parent
  if {$inrow} {
    set rowbody [string trim $rowbody]
    append body $rowbody</td></tr>\n
    if {$dflt_parent!=""} {
      append rowbody " <$dflt_parent>"
    }
    hd_requirement $rowtag $rowbody
    set keyword($rowtag) 1
    set inrow 0
    set rowbody {}
    set rowtag {}
  }
}

  if {$phase==0} {
    # Looking for the CAPI3REF: keyword.  This marks the beginning of
    # an interface definition.  When the CAPI3REF keywords is seen, 
    # record the interface title and then switch to "phase 1".
    #
    if {[regexp {^\*\* CAPI3REF: +(.*)} $line all tx]} {
      set title $tx
      set dflt_parent {}
      regexp {<([AHLS]\d\d\d\d\d)>} $title all dflt_parent
      set title_lineno $lineno
      set phase 1
    }
  } elseif {$phase==1} {
    if {[string range $line 0 1]=="**"} {
      # Record all lines of column following the CAPI3REF keyword as the
      # description of the interface.  Except, look for special keywords

  information can be transfered from from one database to another 
  atomically, or so that queries can join data across multiple
  databases.
} {  
  The SQLite library shall support simultaneous access to multiple
  database files on the same database connection.
}

sysreq S10700 S10000 {
  A database is of little practical use if one is unable to obtain
  information from the database.  Hence:
} {
  The SQLite library shall provide interfaces that allow the application
  to obtain the status and results of SQL operations.
}

</tcl>
<h2>2.0 SQLite is designed to be extensible by the application</h2>
<tcl>

sysreq S20000 {} {
  SQLite is intended to be an embedded database that functions well

  SQLite works on common workstations and in embedded systems.
  Sometimes these devices, particularly embedded systems,
  have odd and unusual operating systems.  In order to support
  this level of portability, SQLite allows the interface to the operating
  system to be defined at run-time.
} {
  The SQLite library shall provide interfaces that permit the application
  to override interfaces to the platform on which the application is running.
}
sysreq S20110 S20100 {} {
  The SQLite library shall provide interfaces that permit the application
  to override the interfaces used to read and write persistent storage.
}
sysreq S20120 S20100 {} {
  The SQLite library shall provide interfaces that permit the application

  The SQLite library shall automatically control access to common
  databases from different connections in different threads or processes.
}
sysreq S40400 S40000 {} {
  The SQLite library shall notify the application if an operation can
  not be completed due to concurrent access constraints.
}
sysreq S40410 S40000 {
  If an SQL statement cannot be completed because another process is
  holding a lock on the database, then the application needs to be able
  to take corrective action, such waiting for the lock to clear.
} {
  The SQLite library shall provide interfaces to assist the application
  in responding appropriately when an operation can
  not be completed due to concurrent access constraints.
}

</tcl>
<h2>5.0 SQLite is cross-platform</h2>
<tcl>

sysreq S50000 {} {
  Cross-platform in this context means that the SQLite 

  different size integers, and different byte orders.  The same
  database file should work on any machine.
} {
  SQLite database files shall by processor and byte-order independent.
}

</tcl>
<h2>6.0 Introspection</h2>
<tcl>

sysreq S60000 {} {
  Some applications need to be able to discover characteristics of
  their environment at run-time and to make appropriate adjustments to
  their processing to accommodate the environment they find themselves in.
  SQLite attempts to support this need.

sysreq S60200 S60000 {
  In addition to the compile-time characteristics, SQLite allows
  the run-time settings of the library and of the underlying
  database file to be interrogated.
} {
  The SQLite library shall provide interfaces that an application can
  use to find run-time performance characteristics and status of the
  SQLite library.
}
sysreq S60300 S60000 {} {
  The SQLite library shall provide interfaces that permit an application
  to query the schema of a database.
}
sysreq S60400 S60000 {} {
  The SQLite library shall provide interfaces that allow an application
  to monitor sequence of queries and progress of submitted to SQLite.
}
sysreq S60500 S60000 {} {
  The SQLite library shall provide interfaces that allow an application
  to discover the algorithms that SQLite has chosen to implement specific
  SQL statements.
}

sysreq S60600 {S60000 S20200} {
  SQLite objects are often related.  For example, every prepared
  statement is associated with a database connection.  And every
  function context is associated with a prepared statement.  
  Applications and extensions frequently find it useful to be able
  to discover these relationships at runtime.  Hence:
} {
  The SQLite library shall provide interfaces that allow an application
  to discover relationships between SQLite objects.
}

</tcl>
<h2>7.0 Features to promote safe and robust application coding practices</h2>
<tcl>

sysreq S70000 {} {
  Many applications need to be able to safely process data or
  even SQL statements that are received from untrusted sources.
  An "SQL Injection Attack" occurs when an adversary intentionally
  introduces data that is designed to have undesirable side effects
  on the database files.  For example, suppose an application generates

  SQLite supports interfaces that allow the CLI and similar applications
  to know if the input it has gathered so far is complete or if it needs
  to await additional input before processing the SQL.
} {
  The SQLite library shall provide interfaces that test to see if an
  SQL statement being received incrementally is complete.
}

sysreq S70300 {S70000 S30000} {
  The concept of a "prepared statement" allows an SQL statement to be
  parsed and compiled once and then reused many times.  This is a performance
  advantage in many applications.  In addition, binding values to variables
  in the prepared statement is safer than embedding values as literals because
  bound values do not need to be quoted in order to avoid an SQL injection
  attack.
} {
  The SQLite library shall support prepared statement objects with
  late parameter binding
}

</tcl>
<h2>8.0 Summary Of System Requirements</h2>

<p>The foregoing contained both system requirements and explanatory
text interspersed.  The following is a reproduction of the system
requirements without the explanatory text, as a convenient reference.
The top-level system requirements are shown first, followed by lower-level
system requirements that provide additional detail.</p>

<h3>8.1 Top-level System Requirements</h3>

<tcl>
foreach {id derivedfrom text} $sysreq_list {
  if {[llength $derivedfrom]>0} continue
  hd_puts "<blockquote><b>$id:</b>"
  hd_resolve $text
  hd_puts </blockquote>
}
</tcl>

<h3>8.2 Derived System Requirements</h3>

<tcl>
foreach {id derivedfrom text} $sysreq_list {
  if {[llength $derivedfrom]==0} continue
  hd_puts "<blockquote><b>$id:</b>"
  hd_resolve $text
  hd_puts </blockquote>
}
</tcl>