lnav/test/expected/test_cmds.sh_b6a3bb78e9d60e5e1f5ce5b18e40d2f1662707ab.out

lnav

A fancy log file viewer for the terminal.

Overview

The Logfile Navigator, lnav, is an enhanced log file viewer that takes
advantage of any semantic information that can be gleaned from the
files being viewed, such as timestamps and log levels. Using this
extra semantic information, lnav can do things like interleaving
messages from different files, generate histograms of messages over
time, and providing hotkeys for navigating through the file. It is
hoped that these features will allow the user to quickly and
efficiently zero in on problems.

Opening Paths/URLs

The main arguments to lnav are the files, directories, glob patterns,
or URLs to be viewed. If no arguments are given, the default syslog
file for your system will be opened. These arguments will be polled
periodically so that any new data or files will be automatically
loaded. If a previously loaded file is removed or replaced, it will be
closed and the replacement opened.

Note: When opening SFTP URLs, if the password is not provided for the
host, the SSH agent can be used to do authentication.

Options

Lnav takes a list of files to view and/or you can use the flag
arguments to load well-known log files, such as the syslog log files.
The flag arguments are:

 •  -a  Load all of the most recent log file types.
 •  -r  Recursively load files from the given directory
   hierarchies.
 •  -R  Load older rotated log files as well.

When using the flag arguments, lnav will look for the files relative
to the current directory and its parent directories. In other words,
if you are working within a directory that has the well-known log
files, those will be preferred over any others.

If you do not want the default syslog file to be loaded when no files
are specified, you can pass the  -N  flag.

Any files given on the command-line are scanned to determine their log
file format and to create an index for each line in the file. You do
not have to manually specify the log file format. The currently
supported formats are: syslog, apache, strace, tcsh history, and
generic log files with timestamps.

Lnav will also display data piped in on the standard input. The
following options are available when doing so:

 •  -t  Prepend timestamps to the lines of data being read
   in on the standard input.
 •  -w file  Write the contents of the standard input to
   this file.

To automatically execute queries or lnav commands after the files have
been loaded, you can use the following options:

 •  -c cmd  A command, query, or file to execute. The
   first character determines the type of operation: a colon
   ( : ) is used for the built-in commands; a semi-colon ( ;
   ) for SQL queries; and a pipe symbol ( | ) for executing
   a file containing other commands. For example, to open
   the file "foo.log" and go to the tenth line in the file,
   you can do:
   
    ▌lnav -c ':goto 10' foo.log              
   
   This option can be given multiple times to execute
   multiple operations in sequence.
 •  -f file  A file that contains commands, queries, or
   files to execute. This option is a shortcut for  -c '|file'
   . You can use a dash ( - ) to execute commands from the
   standard input.

To execute commands/queries without opening the interactive text UI,
you can pass the  -n  option. This combination of options allows you
to write scripts for processing logs with lnav. For example, to get a
list of IP addresses that dhclient has bound to in CSV format:

 ▌#! /usr/bin/lnav -nf                                                                            
 ▌                                                                                                
 ▌# Usage: dhcp_ip.lnav /var/log/messages                                                         
 ▌# Only include lines that look like:                                                            
 ▌# Apr 29 00:31:56 example-centos5 dhclient: bound to 10.1.10.103 -- renewal in 9938 seconds.    
 ▌                                                                                                
 ▌:filter-in dhclient: bound to                                                                   
 ▌                                                                                                
 ▌# The log message parser will extract the IP address                                            
 ▌# as col_0, so we select that and alias it to "dhcp_ip".                                        
 ▌;SELECT DISTINCT col_0 AS dhcp_ip FROM logline;                                                 
 ▌                                                                                                
 ▌# Finally, write the results of the query to stdout.                                            
 ▌:write-csv-to -                                                                                 

Display

The main part of the display shows the log lines from the files
interleaved based on time-of-day. New lines are automatically loaded
as they are appended to the files and, if you are viewing the bottom
of the files, lnav will scroll down to display the new lines, much
like  tail -f .

On color displays, the lines will be highlighted as follows:

 • Errors will be colored in red;
 • warnings will be yellow;
 • boundaries between days will be underlined; and
 • various color highlights will be applied to: IP
   addresses, SQL keywords, XML tags, file and line numbers
   in Java backtraces, and quoted strings.

To give you an idea of where you are spatially, the right side of the
display has a proportionally sized 'scroll bar' that indicates your
current position in the files. The scroll bar will also show areas of
the file where warnings or errors are detected by coloring the bar
yellow or red, respectively. Tick marks will also be added to the left
and right hand side of the bar, for search hits and bookmarks.

A bar on the left side is color coded and broken up to indicate which
messages are from the same file. Pressing the left-arrow or  h  will
reveal the source file names for each message and pressing again will
show the full paths.

Above and below the main body are status lines that display:

 • the current time;
 • the name of the file the top line was pulled from;
 • the log format for the top line;
 • the current view;
 • the line number for the top line in the display;
 • the current search hit, the total number of hits, and
   the search term;

If the view supports filtering, there will be a status line showing
the following:

 • the number of enabled filters and the total number of
   filters;
 • the number of lines not displayed because of filtering.

To edit the filters, you can press TAB to change the focus from the
main view to the filter editor. The editor allows you to create,
enable/disable, and delete filters easily.

Finally, the last line on the display is where you can enter search
patterns and execute internal commands, such as converting a
unix-timestamp into a human-readable date. The command-line is
implemented using the readline library, so the usual set of keyboard
shortcuts are available. Most commands and searches also support
tab-completion.

The body of the display is also used to display other content, such
as: the help file, histograms of the log messages over time, and SQL
results. The views are organized into a stack so that any time you
activate a new view with a key press or command, the new view is
pushed onto the stack. Pressing the same key again will pop the view
off of the stack and return you to the previous view. Note that you
can always use  q  to pop the top view off of the stack.

Default Key Bindings

Views

 Key(s)  Action                                            
═══════════════════════════════════════════════════════════
 ?       View/leave this help message.
 q       Leave the current view or quit the program when in
         the log file view.
 Q       Similar to  q , except it will try to sync the top
         time between the current and former views. For
         example, when leaving the spectrogram view with  Q
         , the top time in that view will be matched to the
         top time in the log view.
 TAB     Toggle focusing on the filter editor or the main
         view.
 a/A     Restore the view that was previously popped with  q
         / Q . The  A  hotkey will try to match the top
         times between the two views.
 X       Close the current text file or log file.

Spatial Navigation

 Key(s)      Action                                            
═══════════════════════════════════════════════════════════════
 g/Home      Move to the top of the file.
 G/End       Move to the end of the file. If the view is
             already at the end, it will move to the last line.
 SPACE/PgDn  Move down a page.
 b/PgUp      Move up a page.
 j/↓         Move down a line.
 k/↑         Move up a line.
 h/←         Move to the left. In the log view, moving left
             will reveal the source log file names for each
             line. Pressing again will reveal the full path.
 l/→         Move to the right.
 H/Shift ←   Move to the left by a smaller increment.
 L/Shift →   Move to the right by a smaller increment.
 e/E         Move to the next/previous error.
 w/W         Move to the next/previous warning.
 n/N         Move to the next/previous search hit. When pressed
             repeatedly within a short time, the view will move
             at least a full page at a time instead of moving
             to the next hit.
 f/F         Move to the next/previous file. In the log view,
             this moves to the next line from a different file.
             In the text view, this rotates the view to the
             next file.
 >/<         Move horizontally to the next/previous search hit.
 o/O         Move forward/backward to the log message with a
             matching 'operation ID' (opid) field.
 u/U         Move forward/backward through any user bookmarks
             you have added using the 'm' key. This hotkey will
             also jump to the start of any log partitions that
             have been created with the 'partition-name'
             command.
 s/S         Move to the next/previous "slow down" in the log
             message rate. A slow down is detected by measuring
             how quickly the message rate has changed over the
             previous several messages. For example, if one
             message is logged every second for five seconds
             and then the last message arrives five seconds
             later, the last message will be highlighted as a
             slow down.
 {/}         Move to the previous/next location in history.
             Whenever you jump to a new location in the view,
             the location will be added to the history. The
             history is not updated when using only the arrow
             keys.

Chronological Navigation

 Key(s)         Action                                            
══════════════════════════════════════════════════════════════════
 d/D            Move forward/backward 24 hours from the current
                position in the log file.
 1-6/Shift 1-6  Move to the next/previous n'th ten minute of the
                hour. For example, '4' would move to the first log
                line in the fortieth minute of the current hour in
                the log. And, '6' would move to the next hour
                boundary.
 7/8            Move to the previous/next minute.
 0/Shift 0      Move to the next/previous day boundary.
 r/R            Move forward/backward based on the relative time
                that was last used with the 'goto' command. For
                example, executing ':goto a minute later' will
                move the log view forward a minute and then
                pressing 'r' will move it forward a minute again.
                Pressing 'R' will then move the view in the
                opposite direction, so backwards a minute.

Bookmarks

 Key(s)  Action                                            
═══════════════════════════════════════════════════════════
 m       Mark/unmark the line at the top of the display.
         The line will be highlighted with reverse video to
         indicate that it is a user bookmark. You can use
         the  u  hotkey to iterate through marks you have
         added.
 M       Mark/unmark all the lines between the top of the
         display and the last line marked/unmarked.
 J       Mark/unmark the next line after the previously
         marked line.
 K       Like  J  except it toggles the mark on the
         previous line.
 c       Copy the marked text to the X11 selection buffer
         or OS X clipboard.
 C       Clear all marked lines.

Display options

 Key(s)         Action                                            
══════════════════════════════════════════════════════════════════
 P              Switch to/from the pretty-printed view of the log
                or text files currently displayed. In this view,
                structured data, such as XML, will be reformatted
                to make it easier to read.
 t              Switch to/from the text file view. The text file
                view is for any files that are not recognized as
                log files.
 =              Pause/unpause loading of new file data.
 Ctrl-L         (Lo-fi mode) Exit screen-mode and write the
                displayed log lines in plain text to the terminal
                until a key is pressed. Useful for copying long
                lines from the terminal without picking up any of
                the extra decorations.
 T              Toggle the display of the "elapsed time" column
                that shows the time elapsed since the beginning of
                the logs or the offset from the previous bookmark.
                Sharp changes in the message rate are highlighted
                by coloring the separator between the time column
                and the log message. A red highlight means the
                message rate has slowed down and green means it
                has sped up. You can use the "s/S" hotkeys to scan
                through the slow downs.
 i              View/leave a histogram of the log messages over
                time. The histogram counts the number of displayed
                log lines for each bucket of time. The bars are
                layed out horizontally with colored segments
                representing the different log levels. You can use
                the  z  hotkey to change the size of the time
                buckets (e.g. ten minutes, one hour, one day).
 I              Switch between the log and histogram views while
                keeping the time displayed at the top of each view
                in sync. For example, if the top line in the log
                view is "11:40", hitting  I  will switch to the
                histogram view and scrolled to display "11:00" at
                the top (if the zoom level is hours).
 z/Shift Z      Zoom in or out one step in the histogram view.
 v              Switch to/from the SQL result view.
 V              Switch between the log and SQL result views while
                keeping the top line number in the log view in
                sync with the log_line column in the SQL view. For
                example, doing a query that selects for
                "log_idle_msecs" and "log_line", you can move the
                top of the SQL view to a line and hit 'V' to
                switch to the log view and move to the line number
                that was selected in the "log_line" column. If
                there is no "log_line" column, lnav will find the
                first column with a timestamp and move to
                corresponding time in the log view.
 TAB/Shift TAB  In the SQL result view, cycle through the columns
                that are graphed. Initially, all number values are
                displayed in a stacked graph. Pressing TAB will
                change the display to only graph the first column.
                Repeatedly pressing TAB will cycle through the
                columns until they are all graphed again.
 p              In the log view: enable or disable the display of
                the fields that the log message parser knows about
                or has discovered. This overlay is temporarily
                enabled when the semicolon key (;) is pressed so
                that it is easier to write queries.
                In the DB view: enable or disable the display of
                values in columns containing JSON-encoded values
                in the top row. The overlay will display the
                JSON-Pointer reference and value for all fields in
                the JSON data.
 CTRL-W         Toggle word-wrapping.
 CTRL-P         Show/hide the data preview panel that may be
                opened when entering commands or SQL queries.
 CTRL-F         Toggle the enabled/disabled state of all filters
                in the current view.
 x              Toggle the hiding of log message fields. The
                hidden fields will be replaced with three bullets
                and highlighted in yellow.
 F2             Toggle mouse support.

Query

 Key(s)               Action                                            
════════════════════════════════════════════════════════════════════════
 /regexp              Start a search for the given regular expression.
                      The search is live, so when there is a pause in
                      typing, the currently running search will be
                      canceled and a new one started. The first ten
                      lines that match the search will be displayed in
                      the preview window at the bottom of the view.
                      History is maintained for your searches so you can
                      rerun them easily. Words that are currently
                      displayed are also available for tab-completion,
                      so you can easily search for values without
                      needing to copy-and-paste the string. If there is
                      an error encountered while trying to interpret the
                      expression, the error will be displayed in red on
                      the status line. While the search is active, the
                      'hits' field in the status line will be green,
                      when finished it will turn back to black.
 :<command>           Execute an internal command. The commands are
                      listed below. History is also supported in this
                      context as well as tab-completion for commands and
                      some arguments. The result of the command replaces
                      the command you typed.
 ;<sql>               Execute an SQL query. Most supported log file
                      formats provide a sqlite virtual table backend
                      that can be used in queries. See the SQL section
                      below for more information.
 |<script> [arg1...]  Execute an lnav script contained in a format
                      directory (e.g. ~/.lnav/formats/default). The
                      script can contain lines starting with  : ,  ; ,
                      or  |  to execute commands, SQL queries or execute
                      other files in lnav. Any values after the script
                      name are treated as arguments can be referenced in
                      the script using  $1 ,  $2 , and so on, like in a
                      shell script.
 CTRL+], ESCAPE       Abort command-line entry started with  / ,  : ,  ;
                      , or  | .

 ▌                Note: The regular expression format used by is PCRE     
 ▌                (Perl-Compatible Regular Expressions).  For example,    
 ▌                if you wanted to search for ethernet device names,      
 ▌                regardless of their ID number, you can type:            
 ▌                                                                        
 ▌                  eth\d+                                                
 ▌                                                                        
 ▌                You can find more information about Perl regular        
 ▌                expressions at:                                         
 ▌                                                                        
 ▌                  http://perldoc.perl.org/perlre.html                   
 ▌                                                                        
 ▌                If the search string is not valid PCRE, a search        
 ▌                is done for the exact string instead of doing a         
 ▌                regex search.                                           

Session

 Key(s)  Action                                            
═══════════════════════════════════════════════════════════
 CTRL-R  Reset the session state. This will save the
         current session state (filters, highlights) and
         then reset the state to the factory default.

Filter Editor

The following hotkeys are only available when the focus is on the
filter editor. You can change the focus by pressing TAB.

 Key(s)  Action                                            
═══════════════════════════════════════════════════════════
 q       Switch the focus back to the main view.
 j/↓     Select the next filter.
 k/↑     Select the previous filter.
 o       Create a new "out" filter.
 i       Create a new "in" filter .
 SPACE   Toggle the enabled/disabled state of the currently
         selected filter.
 t       Toggle the type of filter between "in" and "out".
 ENTER   Edit the selected filter.
 D       Delete the selected filter.

Mouse Support (experimental)

If you are using Xterm, or a compatible terminal, you can use the
mouse to mark lines of text and move the view by grabbing the
scrollbar.

NOTE: You need to manually enable this feature by setting the LNAV_EXP
environment variable to "mouse". F2 toggles mouse support.

SQL Queries (experimental)

Lnav has support for performing SQL queries on log files using the
Sqlite3 "virtual" table feature. For all supported log file types,
lnav will create tables that can be queried using the subset of SQL
that is supported by Sqlite3. For example, to get the top ten URLs
being accessed in any loaded Apache log files, you can execute:

 ▌;SELECT cs_uri_stem, count(*) AS total FROM access_log    
 ▌   GROUP BY cs_uri_stem ORDER BY total DESC LIMIT 10;     

The query result view shows the results and graphs any numeric values
found in the result, much like the histogram view.

The builtin set of log tables are listed below. Note that only the log
messages that match a particular format can be queried by a particular
table. You can find the file format and table name for the top log
message by looking in the upper right hand corner of the log file
view.

Some commonly used format tables are:

 Name         Description                                       
════════════════════════════════════════════════════════════════
 access_log   Apache common access log format
 syslog_log   Syslog format
 strace_log   Strace log format
 generic_log  'Generic' log format. This table contains messages
              from files that have a very simple format with a
              leading timestamp followed by the message.

NOTE: You can get a dump of the schema for the internal tables, and
any attached databases, by running the  .schema  SQL command.

The columns available for the top log line in the view will
automatically be displayed after pressing the semicolon ( ; ) key. All
log tables contain at least the following columns:

 Column          Description                                       
═══════════════════════════════════════════════════════════════════
 log_line        The line number in the file, starting at zero.
 log_part        The name of the partition.  You can change this
                 column using an UPDATE SQL statement or with the
                 'partition-name' command.  After a value is set,
                 the following log messages will have the same
                 partition name up until another name is set.
 log_time        The time of the log entry.
 log_idle_msecs  The amount of time, in milliseconds, between the
                 current log message and the previous one.
 log_level       The log level (e.g. info, error, etc...).
 log_mark        The bookmark status for the line.  This column can
                 be written to using an UPDATE query.
 log_path        The full path to the file.
 log_text        The raw line of text.  Note that this column is
                 not included in the result of a 'select *', but it
                 does exist.

The following tables include the basic columns as listed above and
include a few more columns since the log file format is more
structured.

 •  syslog_log 
   
    Column        Description                                       
   ═════════════════════════════════════════════════════════════════
    log_hostname  The hostname the message was received from.
    log_procname  The name of the process that sent the message.
    log_pid       The process ID of the process that sent the
                  message.
 •  access_log  (The column names are the same as those in
   the Microsoft LogParser tool.)
   
    Column         Description                               
   ══════════════════════════════════════════════════════════
    c_ip           The client IP address.
    cs_username    The client user name.
    cs_method      The HTTP method.
    cs_uri_stem    The stem portion of the URI.
    cs_uri_query   The query portion of the URI.
    cs_version     The HTTP version string.
    sc_status      The status number returned to the client.
    sc_bytes       The number of bytes sent to the client.
    cs_referrer    The URL of the referring page.
    cs_user_agent  The user agent string.
 •  strace_log  (Currently, you need to run strace with
   the  -tt -T options so there are timestamps for each
   function call.)
   
    Column       Description                              
   ═══════════════════════════════════════════════════════
    funcname     The name of the syscall.
    result       The result code.
    duration     The amount of time spent in the syscall.
    arg0 - arg9  The arguments passed to the syscall.

These tables are created dynamically and not stored in memory or on
disk. If you would like to persist some information from the tables,
you can attach another database and create tables in that database.
For example, if you wanted to save the results from the earlier
example of a top ten query into the "/tmp/topten.db" file, you can do:

 ▌;ATTACH DATABASE '/tmp/topten.db' AS topten;                         
 ▌;CREATE TABLE topten.foo AS SELECT cs_uri_stem, count(*) AS total    
 ▌   FROM access_log GROUP BY cs_uri_stem ORDER BY total DESC          
 ▌   LIMIT 10;                                                         

Dynamic logline Table (experimental)

(NOTE: This feature is still very new and not completely reliable yet,
use with care.)

For log formats that lack message structure, lnav can parse the log
message and attempt to extract any data fields that it finds. This
feature is available through the  logline  log table. This table is
dynamically created and defined based on the message at the top of the
log view. For example, given the following log message from "sudo",
lnav will create the "logline" table with columns for "TTY", "PWD",
"USER", and "COMMAND":

 ▌May 24 06:48:38 Tim-Stacks-iMac.local sudo[76387]: stack : TTY=ttys003 ; PWD=/Users/stack/github/lbuild ; USER=root ; COMMAND=/bin/echo Hello, World!    

Queries executed against this table will then only return results for
other log messages that have the same format. So, if you were to
execute the following query while viewing the above line, you might
get the following results:

 ▌;SELECT USER,COMMAND FROM logline;      

 USER  COMMAND                   
═════════════════════════════════
 root  /bin/echo Hello, World!
 mal   /bin/echo Goodbye, World!

The log parser works by examining each message for key/value pairs
separated by an equal sign (=) or a colon (:). For example, in the
previous example of a "sudo" message, the parser sees the "USER=root"
string as a pair where the key is "USER" and the value is "root". If
no pairs can be found, then anything that looks like a value is
extracted and assigned a numbered column. For example, the following
line is from "dhcpd":

 ▌Sep 16 22:35:57 drill dhcpd: DHCPDISCOVER from 00:16:ce:54:4e:f3 via hme3    

In this case, the lnav parser recognizes that "DHCPDISCOVER", the MAC
address and the "hme3" device name are values and not normal words.
So, it builds a table with three columns for each of these values. The
regular words in the message, like "from" and "via", are then used to
find other messages with a similar format.

If you would like to execute queries against log messages of different
formats at the same time, you can use the 'create-logline-table'
command to permanently create a table using the top line of the log
view as a template.

Other SQL Features

Environment variables can be used in SQL statements by prefixing the
variable name with a dollar-sign ($). For example, to read the value
of the  HOME  variable, you can do:

 ▌;SELECT $HOME;                          

To select the syslog messages that have a hostname field that is equal
to the  HOSTNAME  variable:

 ▌;SELECT * FROM syslog_log WHERE log_hostname = $HOSTNAME;    

NOTE: Variable substitution is done for fields in the query and is not
a plain text substitution. For example, the following statement WILL
NOT WORK:

 ▌;SELECT * FROM $TABLE_NAME; -- Syntax error    

Access to lnav's environment variables is also available via the
"environ" table. The table has two columns (name, value) and can be
read and written to using SQL SELECT, INSERT, UPDATE, and DELETE
statements. For example, to set the "FOO" variable to the value "BAR":

 ▌;INSERT INTO environ SELECT 'FOO', 'BAR';    

As a more complex example, you can set the variable "LAST" to the last
syslog line number by doing:

 ▌;INSERT INTO environ SELECT 'LAST', (SELECT max(log_line) FROM syslog_log);    

A delete will unset the environment variable:

 ▌;DELETE FROM environ WHERE name='LAST';    

The table allows you to easily use the results of a SQL query in lnav
commands, which is especially useful when scripting lnav.

Contact

For more information, visit the lnav website at:

http://lnav.org[1]

 ▌[1] - http://lnav.org 

For support questions, email:

lnav@googlegroups.com[1] support@lnav.org[2]

 ▌[1] - mailto:lnav@googlegroups.com 
 ▌[2] - mailto:support@lnav.org      

Command Reference

:adjust-log-time timestamp
══════════════════════════════════════════════════════════════════════
  Change the timestamps of the top file to be relative to the given
  date
Parameter
  timestamp   The new timestamp for the top line in the
              view

Examples
#1 To set the top timestamp to a given date:
   :adjust-log-time 2017-01-02T05:33:00              
   

#2 To set the top timestamp back an hour:
   :adjust-log-time -1h                              
   


:alt-msg msg
══════════════════════════════════════════════════════════════════════
  Display a message in the alternate command position
Parameter
  msg   The message to display
See Also
  :echo, :eval, :redirect-to, :write-csv-to, :write-json-to, 
  :write-jsonlines-to, :write-raw-to, :write-screen-to, :write-table-to, 
  :write-to, :write-view-to
Example
#1 To display 'Press t to switch to the text view' on the bottom right:
   :alt-msg Press t to switch to the text view       
   


:append-to path
══════════════════════════════════════════════════════════════════════
  Append marked lines in the current view to the given file
Parameter
  path   The path to the file to append to
See Also
  :echo, :pipe-line-to, :pipe-to, :redirect-to, :write-csv-to, 
  :write-json-to, :write-jsonlines-to, :write-raw-to, :write-screen-to, 
  :write-table-to, :write-to, :write-view-to
Example
#1 To append marked lines to the file /tmp/interesting-lines.txt:
   :append-to /tmp/interesting-lines.txt             
   


:clear-comment
══════════════════════════════════════════════════════════════════════
  Clear the comment attached to the top log line
See Also
  :comment, :tag

:clear-filter-expr
══════════════════════════════════════════════════════════════════════
  Clear the filter expression
See Also
  :filter-expr, :filter-in, :filter-out, :hide-lines-after, 
  :hide-lines-before, :hide-unmarked-lines, :toggle-filtering

:clear-highlight pattern
══════════════════════════════════════════════════════════════════════
  Remove a previously set highlight regular expression
Parameter
  pattern   The regular expression previously used with
            :highlight
See Also
  :enable-word-wrap, :hide-fields, :highlight
Example
#1 To clear the highlight with the pattern 'foobar':
   :clear-highlight foobar                           
   


:clear-mark-expr
══════════════════════════════════════════════════════════════════════
  Clear the mark expression
See Also
  :hide-unmarked-lines, :mark, :mark-expr, :next-mark, :prev-mark

:clear-partition
══════════════════════════════════════════════════════════════════════
  Clear the partition the top line is a part of


:close
══════════════════════════════════════════════════════════════════════
  Close the top file in the view


:comment text
══════════════════════════════════════════════════════════════════════
  Attach a comment to the top log line
Parameter
  text   The comment text
See Also
  :clear-comment, :tag
Example
#1 To add the comment 'This is where it all went wrong' to the top line:
   :comment This is where it all went wrong          
   


:config option [value]
══════════════════════════════════════════════════════════════════════
  Read or write a configuration option
Parameters
  option   The path to the option to read or write
  value    The value to write.  If not given, the current
           value is returned
See Also
  :reset-config
Examples
#1 To read the configuration of the '/ui/clock-format' option:
   :config /ui/clock-format                          
   

#2 To set the '/ui/dim-text' option to 'false':
   :config /ui/dim-text false                        
   


:create-logline-table table-name
══════════════════════════════════════════════════════════════════════
  Create an SQL table using the top line of the log view as a template
Parameter
  table-name   The name for the new table
See Also
  :create-search-table, :create-search-table, :write-csv-to, 
  :write-json-to, :write-jsonlines-to, :write-raw-to, :write-screen-to, 
  :write-table-to, :write-view-to
Example
#1 To create a logline-style table named 'task_durations':
   :create-logline-table task_durations              
   


:create-search-table table-name [pattern]
══════════════════════════════════════════════════════════════════════
  Create an SQL table based on a regex search
Parameters
  table-name   The name of the table to create
  pattern      The regular expression used to capture the
               table columns.  If not given, the current search
               pattern is used.
See Also
  :create-logline-table, :create-logline-table, :delete-search-table, 
  :delete-search-table, :write-csv-to, :write-json-to, 
  :write-jsonlines-to, :write-raw-to, :write-screen-to, :write-table-to, 
  :write-view-to
Example
#1 To create a table named 'task_durations' that matches log messages with the pattern
   'duration=(?<duration>\d+)':
   :create-search-table task_durations duration=(?<duration>\d+)
   


:current-time
══════════════════════════════════════════════════════════════════════
  Print the current time in human-readable form and seconds since the
  epoch


:delete-filter pattern
══════════════════════════════════════════════════════════════════════
  Delete the filter created with :filter-in or :filter-out
Parameter
  pattern   The regular expression to match
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, 
  :hide-unmarked-lines, :toggle-filtering
Example
#1 To delete the filter with the pattern 'last message repeated':
   :delete-filter last message repeated              
   


:delete-logline-table table-name
══════════════════════════════════════════════════════════════════════
  Delete a table created with create-logline-table
Parameter
  table-name   The name of the table to delete
See Also
  :create-logline-table, :create-logline-table, :create-search-table, 
  :create-search-table, :write-csv-to, :write-json-to, 
  :write-jsonlines-to, :write-raw-to, :write-screen-to, :write-table-to, 
  :write-view-to
Example
#1 To delete the logline-style table named 'task_durations':
   :delete-logline-table task_durations              
   


:delete-search-table table-name
══════════════════════════════════════════════════════════════════════
  Create an SQL table based on a regex search
Parameter
  table-name   The name of the table to create
See Also
  :create-logline-table, :create-logline-table, :create-search-table, 
  :create-search-table, :write-csv-to, :write-json-to, 
  :write-jsonlines-to, :write-raw-to, :write-screen-to, :write-table-to, 
  :write-view-to
Example
#1 To delete the search table named 'task_durations':
   :delete-search-table task_durations               
   


:delete-tags tag1 [... tagN]
══════════════════════════════════════════════════════════════════════
  Remove the given tags from all log lines
Parameter
  tag   The tags to delete
See Also
  :comment, :tag
Example
#1 To remove the tags '#BUG123' and '#needs-review' from all log lines:
   :delete-tags #BUG123 #needs-review                
   


:disable-filter pattern
══════════════════════════════════════════════════════════════════════
  Disable a filter created with filter-in/filter-out
Parameter
  pattern   The regular expression used in the filter
            command
See Also
  :enable-filter, :filter-in, :filter-out, :hide-lines-after, 
  :hide-lines-before, :hide-unmarked-lines, :toggle-filtering
Example
#1 To disable the filter with the pattern 'last message repeated':
   :disable-filter last message repeated             
   


:disable-word-wrap
══════════════════════════════════════════════════════════════════════
  Disable word-wrapping for the current view
See Also
  :enable-word-wrap, :hide-fields, :highlight

:echo msg
══════════════════════════════════════════════════════════════════════
  Echo the given message to the screen or, if :redirect-to has been
  called, to output file specified in the redirect.  Variable
  substitution is performed on the message.  Use a backslash to escape
  any special characters, like '$'
Parameter
  msg   The message to display
See Also
  :alt-msg, :append-to, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-json-to, 
  :write-json-to, :write-jsonlines-to, :write-jsonlines-to, 
  :write-raw-to, :write-raw-to, :write-screen-to, :write-screen-to, 
  :write-table-to, :write-table-to, :write-to, :write-to, :write-view-to, 
  :write-view-to
Example
#1 To output 'Hello, World!':
   :echo Hello, World!                               
   


:enable-filter pattern
══════════════════════════════════════════════════════════════════════
  Enable a previously created and disabled filter
Parameter
  pattern   The regular expression used in the filter
            command
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, 
  :hide-unmarked-lines, :toggle-filtering
Example
#1 To enable the disabled filter with the pattern 'last message repeated':
   :enable-filter last message repeated              
   


:enable-word-wrap
══════════════════════════════════════════════════════════════════════
  Enable word-wrapping for the current view
See Also
  :disable-word-wrap, :hide-fields, :highlight

:eval command
══════════════════════════════════════════════════════════════════════
  Evaluate the given command/query after doing environment variable
  substitution
Parameter
  command   The command or query to perform substitution on.
See Also
  :alt-msg, :echo, :redirect-to, :write-csv-to, :write-json-to, 
  :write-jsonlines-to, :write-raw-to, :write-screen-to, :write-table-to, 
  :write-to, :write-view-to
Example
#1 To substitute the table name from a variable:
   :eval ;SELECT * FROM ${table}                     
   


:filter-expr expr
══════════════════════════════════════════════════════════════════════
  Set the filter expression
Parameter
  expr   The SQL expression to evaluate for each log message.
         The message values can be accessed using column names
         prefixed with a colon
See Also
  :clear-filter-expr, :filter-in, :filter-out, :hide-lines-after, 
  :hide-lines-before, :hide-unmarked-lines, :toggle-filtering
Examples
#1 To set a filter expression that matched syslog messages from 'syslogd':
   :filter-expr :log_procname = 'syslogd'            
   

#2 To set a filter expression that matches log messages where 'id' is followed by a
   number and contains the string 'foo':
   :filter-expr :log_body REGEXP 'id\d+' AND :log_body REGEXP 'foo'
   


:filter-in pattern
══════════════════════════════════════════════════════════════════════
  Only show lines that match the given regular expression in the
  current view
Parameter
  pattern   The regular expression to match
See Also
  :delete-filter, :disable-filter, :filter-out, :hide-lines-after, 
  :hide-lines-before, :hide-unmarked-lines, :toggle-filtering
Example
#1 To filter out log messages that do not have the string 'dhclient':
   :filter-in dhclient                               
   


:filter-out pattern
══════════════════════════════════════════════════════════════════════
  Remove lines that match the given regular expression in the current
  view
Parameter
  pattern   The regular expression to match
See Also
  :delete-filter, :disable-filter, :filter-in, :hide-lines-after, 
  :hide-lines-before, :hide-unmarked-lines, :toggle-filtering
Example
#1 To filter out log messages that contain the string 'last message repeated':
   :filter-out last message repeated                 
   


:goto line#|N%|timestamp
══════════════════════════════════════════════════════════════════════
  Go to the given location in the top view
Parameter
  line#|N%|timestamp   A line number, percent
                       into the file, or a timestamp
See Also
  :next-location, :next-mark, :prev-location, :prev-mark, :relative-goto
Examples
#1 To go to line 22:
   :goto 22                                          
   

#2 To go to the line 75% of the way into the view:
   :goto 75%                                         
   

#3 To go to the first message on the first day of 2017:
   :goto 2017-01-01                                  
   


:help
══════════════════════════════════════════════════════════════════════
  Open the help text view


:hide-fields field-name1 [... field-nameN]
══════════════════════════════════════════════════════════════════════
  Hide log message fields by replacing them with an ellipsis
Parameter
  field-name   The name of the field to hide in the
               format for the top log line.  A qualified name can be
               used where the field name is prefixed by the format
               name and a dot to hide any field.
See Also
  :enable-word-wrap, :highlight, :show-fields
Examples
#1 To hide the log_procname fields in all formats:
   :hide-fields log_procname                         
   

#2 To hide only the log_procname field in the syslog format:
   :hide-fields syslog_log.log_procname              
   


:hide-file path
══════════════════════════════════════════════════════════════════════
  Hide the given file(s) and skip indexing until it is shown again.
  If no path is given, the current file in the view is hidden
Parameter
  path   A path or glob pattern that specifies the files to
         hide


:hide-lines-after date
══════════════════════════════════════════════════════════════════════
  Hide lines that come after the given date
Parameter
  date   An absolute or relative date
See Also
  :filter-in, :filter-out, :hide-lines-before, :hide-unmarked-lines, 
  :show-lines-before-and-after, :toggle-filtering
Examples
#1 To hide the lines after the top line in the view:
   :hide-lines-after here                            
   

#2 To hide the lines after 6 AM today:
   :hide-lines-after 6am                             
   


:hide-lines-before date
══════════════════════════════════════════════════════════════════════
  Hide lines that come before the given date
Parameter
  date   An absolute or relative date
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-unmarked-lines, 
  :show-lines-before-and-after, :toggle-filtering
Examples
#1 To hide the lines before the top line in the view:
   :hide-lines-before here                           
   

#2 To hide the log messages before 6 AM today:
   :hide-lines-before 6am                            
   


:hide-unmarked-lines
══════════════════════════════════════════════════════════════════════
  Hide lines that have not been bookmarked
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, :mark, 
  :next-mark, :prev-mark, :toggle-filtering

:highlight pattern
══════════════════════════════════════════════════════════════════════
  Add coloring to log messages fragments that match the given regular
  expression
Parameter
  pattern   The regular expression to match
See Also
  :clear-highlight, :enable-word-wrap, :hide-fields
Example
#1 To highlight numbers with three or more digits:
   :highlight \d{3,}                                 
   


:load-session
══════════════════════════════════════════════════════════════════════
  Load the latest session state


:mark
══════════════════════════════════════════════════════════════════════
  Toggle the bookmark state for the top line in the current view
See Also
  :hide-unmarked-lines, :next-mark, :prev-mark

:mark-expr expr
══════════════════════════════════════════════════════════════════════
  Set the bookmark expression
Parameter
  expr   The SQL expression to evaluate for each log message.
         The message values can be accessed using column names
         prefixed with a colon
See Also
  :clear-mark-expr, :hide-unmarked-lines, :mark, :next-mark, :prev-mark
Example
#1 To mark lines from 'dhclient' that mention 'eth0':
   :mark-expr :log_procname = 'dhclient' AND :log_body LIKE '%eth0%'
   


:next-location
══════════════════════════════════════════════════════════════════════
  Move to the next position in the location history
See Also
  :goto, :next-mark, :prev-location, :prev-mark, :relative-goto

:next-mark type1 [... typeN]
══════════════════════════════════════════════════════════════════════
  Move to the next bookmark of the given type in the current view
Parameter
  type   The type of bookmark -- error, warning, search, user,
         file, meta
See Also
  :goto, :hide-unmarked-lines, :mark, :next-location, :prev-location, 
  :prev-mark, :prev-mark, :relative-goto
Example
#1 To go to the next error:
   :next-mark error                                  
   


:open path1 [... pathN]
══════════════════════════════════════════════════════════════════════
  Open the given file(s) in lnav.  Opening files on machines
  accessible via SSH can be done using the syntax:
  [user@]host:/path/to/logs
Parameter
  path   The path to the file to open

Examples
#1 To open the file '/path/to/file':
   :open /path/to/file                               
   

#2 To open the remote file '/var/log/syslog.log':
   :open dean@host1.example.com:/var/log/syslog.log  
   


:partition-name name
══════════════════════════════════════════════════════════════════════
  Mark the top line in the log view as the start of a new partition
  with the given name
Parameter
  name   The name for the new partition

Example
#1 To mark the top line as the start of the partition named 'boot #1':
   :partition-name boot #1                           
   


:pipe-line-to shell-cmd
══════════════════════════════════════════════════════════════════════
  Pipe the top line to the given shell command
Parameter
  shell-cmd   The shell command-line to execute
See Also
  :append-to, :echo, :pipe-to, :redirect-to, :write-csv-to, 
  :write-json-to, :write-jsonlines-to, :write-raw-to, :write-screen-to, 
  :write-table-to, :write-to, :write-view-to
Example
#1 To write the top line to 'sed' for processing:
   :pipe-line-to sed -e 's/foo/bar/g'                
   


:pipe-to shell-cmd
══════════════════════════════════════════════════════════════════════
  Pipe the marked lines to the given shell command
Parameter
  shell-cmd   The shell command-line to execute
See Also
  :append-to, :echo, :pipe-line-to, :redirect-to, :write-csv-to, 
  :write-json-to, :write-jsonlines-to, :write-raw-to, :write-screen-to, 
  :write-table-to, :write-to, :write-view-to
Example
#1 To write marked lines to 'sed' for processing:
   :pipe-to sed -e s/foo/bar/g                       
   


:prev-location
══════════════════════════════════════════════════════════════════════
  Move to the previous position in the location history
See Also
  :goto, :next-location, :next-mark, :prev-mark, :relative-goto

:prev-mark type1 [... typeN]
══════════════════════════════════════════════════════════════════════
  Move to the previous bookmark of the given type in the current view
Parameter
  type   The type of bookmark -- error, warning, search, user,
         file, meta
See Also
  :goto, :hide-unmarked-lines, :mark, :next-location, :next-mark, 
  :next-mark, :prev-location, :relative-goto
Example
#1 To go to the previous error:
   :prev-mark error                                  
   


:prompt type [--alt] [prompt] [initial-value]
══════════════════════════════════════════════════════════════════════
  Open the given prompt
Parameters
  type            The type of prompt -- command,
                  script, search, sql, user
  --alt           Perform the alternate action for
                  this prompt by default
  prompt          The prompt to display
  initial-value   The initial value to fill in for the
                  prompt

Examples
#1 To open the command prompt with 'filter-in' already filled in:
   :prompt command : 'filter-in '                    
   

#2 To ask the user a question:
   :prompt user 'Are you sure? '                     
   


:quit
══════════════════════════════════════════════════════════════════════
  Quit lnav


:quit
══════════════════════════════════════════════════════════════════════
  Quit lnav


:quit
══════════════════════════════════════════════════════════════════════
  Quit lnav


:redirect-to [path]
══════════════════════════════════════════════════════════════════════
  Redirect the output of commands that write to stdout to the given
  file
Parameter
  path   The path to the file to write.  If not specified, the
         current redirect will be cleared
See Also
  :alt-msg, :append-to, :echo, :echo, :eval, :pipe-line-to, :pipe-to, 
  :write-csv-to, :write-csv-to, :write-json-to, :write-json-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-raw-to, :write-raw-to, 
  :write-screen-to, :write-screen-to, :write-table-to, :write-table-to, 
  :write-to, :write-to, :write-view-to, :write-view-to
Example
#1 To write the output of lnav commands to the file /tmp/script-output.txt:
   :redirect-to /tmp/script-output.txt               
   


:redraw
══════════════════════════════════════════════════════════════════════
  Do a full redraw of the screen


:relative-goto line-count|N%
══════════════════════════════════════════════════════════════════════
  Move the current view up or down by the given amount
Parameter
  line-count|N%   The amount to move the view by.
See Also
  :goto, :next-location, :next-mark, :prev-location, :prev-mark
Examples
#1 To move 22 lines down in the view:
   :relative-goto +22                                
   

#2 To move 10 percent back in the view:
   :relative-goto -10%                               
   


:reset-config option
══════════════════════════════════════════════════════════════════════
  Reset the configuration option to its default value
Parameter
  option   The path to the option to reset
See Also
  :config
Example
#1 To reset the '/ui/clock-format' option back to the builtin default:
   :reset-config /ui/clock-format                    
   


:reset-session
══════════════════════════════════════════════════════════════════════
  Reset the session state, clearing all filters, highlights, and
  bookmarks


:save-session
══════════════════════════════════════════════════════════════════════
  Save the current state as a session


:session lnav-command
══════════════════════════════════════════════════════════════════════
  Add the given command to the session file (~/.lnav/session)
Parameter
  lnav-command   The lnav command to save.

Example
#1 To add the command ':highlight foobar' to the session file:
   :session :highlight foobar                        
   


:set-min-log-level log-level
══════════════════════════════════════════════════════════════════════
  Set the minimum log level to display in the log view
Parameter
  log-level   The new minimum log level

Example
#1 To set the minimum log level displayed to error:
   :set-min-log-level error                          
   


:show-fields field-name1 [... field-nameN]
══════════════════════════════════════════════════════════════════════
  Show log message fields that were previously hidden
Parameter
  field-name   The name of the field to show
See Also
  :enable-word-wrap, :hide-fields, :highlight
Example
#1 To show all the log_procname fields in all formats:
   :show-fields log_procname                         
   


:show-file path
══════════════════════════════════════════════════════════════════════
  Show the given file(s) and resume indexing.
Parameter
  path   The path or glob pattern that specifies the files to
         show


:show-lines-before-and-after
══════════════════════════════════════════════════════════════════════
  Show lines that were hidden by the 'hide-lines' commands
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, 
  :hide-unmarked-lines, :toggle-filtering

:show-only-this-file
══════════════════════════════════════════════════════════════════════
  Show only the file for the top line in the view


:show-unmarked-lines
══════════════════════════════════════════════════════════════════════
  Show lines that have not been bookmarked
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, 
  :hide-unmarked-lines, :hide-unmarked-lines, :mark, :next-mark, 
  :prev-mark, :toggle-filtering

:spectrogram field-name
══════════════════════════════════════════════════════════════════════
  Visualize the given message field using a spectrogram
Parameter
  field-name   The name of the numeric field to
               visualize.

Example
#1 To visualize the sc_bytes field in the access_log format:
   :spectrogram sc_bytes                             
   


:summarize column-name
══════════════════════════════════════════════════════════════════════
  Execute a SQL query that computes the characteristics of the values
  in the given column
Parameter
  column-name   The name of the column to analyze.

Example
#1 To get a summary of the sc_bytes column in the access_log table:
   :summarize sc_bytes                               
   


:switch-to-view view-name
══════════════════════════════════════════════════════════════════════
  Switch to the given view
Parameter
  view-name   The name of the view to switch to.

Example
#1 To switch to the 'schema' view:
   :switch-to-view schema                            
   


:tag tag1 [... tagN]
══════════════════════════════════════════════════════════════════════
  Attach tags to the top log line
Parameter
  tag   The tags to attach
See Also
  :comment, :delete-tags, :untag
Example
#1 To add the tags '#BUG123' and '#needs-review' to the top line:
   :tag #BUG123 #needs-review                        
   


:toggle-filtering
══════════════════════════════════════════════════════════════════════
  Toggle the filtering flag for the current view
See Also
  :filter-in, :filter-out, :hide-lines-after, :hide-lines-before, 
  :hide-unmarked-lines

:toggle-view view-name
══════════════════════════════════════════════════════════════════════
  Switch to the given view or, if it is already displayed, switch to
  the previous view
Parameter
  view-name   The name of the view to toggle the display
              of.

Example
#1 To switch to the 'schema' view if it is not displayed or switch back to the previous
   view:
   :toggle-view schema                               
   


:unix-time seconds
══════════════════════════════════════════════════════════════════════
  Convert epoch time to a human-readable form
Parameter
  seconds   The epoch timestamp to convert

Example
#1 To convert the epoch time 1490191111:
   :unix-time 1490191111                             
   


:untag tag1 [... tagN]
══════════════════════════════════════════════════════════════════════
  Detach tags from the top log line
Parameter
  tag   The tags to detach
See Also
  :comment, :tag
Example
#1 To remove the tags '#BUG123' and '#needs-review' from the top line:
   :untag #BUG123 #needs-review                      
   


:write-table-to path
══════════════════════════════════════════════════════════════════════
  Write SQL results to the given file in a tabular format
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-raw-to, :write-raw-to, 
  :write-raw-to, :write-screen-to, :write-screen-to, :write-screen-to, 
  :write-to, :write-to, :write-view-to, :write-view-to, :write-view-to
Example
#1 To write SQL results as text to /tmp/table.txt:
   :write-table-to /tmp/table.txt                    
   


:write-csv-to path
══════════════════════════════════════════════════════════════════════
  Write SQL results to the given file in CSV format
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-json-to, :write-json-to, :write-json-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-jsonlines-to, 
  :write-raw-to, :write-raw-to, :write-raw-to, :write-screen-to, 
  :write-screen-to, :write-screen-to, :write-table-to, :write-table-to, 
  :write-table-to, :write-to, :write-to, :write-view-to, :write-view-to, 
  :write-view-to
Example
#1 To write SQL results as CSV to /tmp/table.csv:
   :write-csv-to /tmp/table.csv                      
   


:write-json-to path
══════════════════════════════════════════════════════════════════════
  Write SQL results to the given file in JSON format
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-jsonlines-to, 
  :write-raw-to, :write-raw-to, :write-raw-to, :write-screen-to, 
  :write-screen-to, :write-screen-to, :write-table-to, :write-table-to, 
  :write-table-to, :write-to, :write-to, :write-view-to, :write-view-to, 
  :write-view-to
Example
#1 To write SQL results as JSON to /tmp/table.json:
   :write-json-to /tmp/table.json                    
   


:write-jsonlines-to path
══════════════════════════════════════════════════════════════════════
  Write SQL results to the given file in JSON Lines format
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-raw-to, 
  :write-raw-to, :write-raw-to, :write-screen-to, :write-screen-to, 
  :write-screen-to, :write-table-to, :write-table-to, :write-table-to, 
  :write-to, :write-to, :write-view-to, :write-view-to, :write-view-to
Example
#1 To write SQL results as JSON Lines to /tmp/table.json:
   :write-jsonlines-to /tmp/table.json               
   


:write-raw-to [--view={log,db}] path
══════════════════════════════════════════════════════════════════════
  In the log view, write the original log file content of the marked
  messages to the file.  In the DB view, the contents of the cells are
  written to the output file.
Parameters
  --view={log,db}   The view to use as the source of
                    data
  path              The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-screen-to, 
  :write-screen-to, :write-screen-to, :write-table-to, :write-table-to, 
  :write-table-to, :write-to, :write-to, :write-view-to, :write-view-to, 
  :write-view-to
Example
#1 To write the marked lines in the log view to /tmp/table.txt:
   :write-raw-to /tmp/table.txt                      
   


:write-screen-to path
══════════════════════════════════════════════════════════════════════
  Write the displayed text or SQL results to the given file without
  any formatting
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-raw-to, :write-raw-to, 
  :write-raw-to, :write-table-to, :write-table-to, :write-table-to, 
  :write-to, :write-to, :write-view-to, :write-view-to, :write-view-to
Example
#1 To write only the displayed text to /tmp/table.txt:
   :write-screen-to /tmp/table.txt                   
   


:write-table-to path
══════════════════════════════════════════════════════════════════════
  Write SQL results to the given file in a tabular format
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-raw-to, :write-raw-to, 
  :write-raw-to, :write-screen-to, :write-screen-to, :write-screen-to, 
  :write-to, :write-to, :write-view-to, :write-view-to, :write-view-to
Example
#1 To write SQL results as text to /tmp/table.txt:
   :write-table-to /tmp/table.txt                    
   


:write-to path
══════════════════════════════════════════════════════════════════════
  Overwrite the given file with any marked lines in the current view
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :echo, :echo, :eval, :pipe-line-to, :pipe-to, 
  :redirect-to, :redirect-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-raw-to, :write-raw-to, :write-screen-to, 
  :write-screen-to, :write-table-to, :write-table-to, :write-view-to, 
  :write-view-to
Example
#1 To write marked lines to the file /tmp/interesting-lines.txt:
   :write-to /tmp/interesting-lines.txt              
   


:write-view-to path
══════════════════════════════════════════════════════════════════════
  Write the text in the top view to the given file without any
  formatting
Parameter
  path   The path to the file to write
See Also
  :alt-msg, :append-to, :create-logline-table, :create-search-table, 
  :echo, :echo, :eval, :pipe-line-to, :pipe-to, :redirect-to, 
  :redirect-to, :write-csv-to, :write-csv-to, :write-csv-to, 
  :write-json-to, :write-json-to, :write-json-to, :write-jsonlines-to, 
  :write-jsonlines-to, :write-jsonlines-to, :write-raw-to, :write-raw-to, 
  :write-raw-to, :write-screen-to, :write-screen-to, :write-screen-to, 
  :write-table-to, :write-table-to, :write-table-to, :write-to, 
  :write-to
Example
#1 To write the top view to /tmp/table.txt:
   :write-view-to /tmp/table.txt                     
   


:zoom-to zoom-level
══════════════════════════════════════════════════════════════════════
  Zoom the histogram view to the given level
Parameter
  zoom-level   The zoom level

Example
#1 To set the zoom level to '1-week':
   :zoom-to 1-week                                   
   

SQL Reference

CAST(expr AS type-name)
══════════════════════════════════════════════════════════════════════
  Convert the value of the given expression to a different storage
  class specified by type-name.
Parameters
  expr        The value to convert.
  type-name   The name of the type to convert to.

Example
#1 To cast the value 1.23 as an integer:
   ;SELECT CAST(1.23 AS INTEGER)                      
   


OVER([base-window-name] PARTITION BY expr, ... ORDER BY expr, ..., 
       [frame-spec])
══════════════════════════════════════════════════════════════════════
       Executes the preceding function over a window
Parameters
  base-window-name   The name of the window
                     definition
  expr               The values to use for
                     partitioning
  expr               The values used to order the
                     rows in the window
  frame-spec         Determines which output rows
                     are read by an aggregate window function


abs(x)
══════════════════════════════════════════════════════════════════════
  Return the absolute value of the argument
Parameter
  x   The number to convert
See Also
  acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the absolute value of -1:
   ;SELECT abs(-1)                                    
   


acos(num)
══════════════════════════════════════════════════════════════════════
  Returns the arccosine of a number, in radians
Parameter
  num   A cosine value that is between -1 and 1
See Also
  abs(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the arccosine of 0.2:
   ;SELECT acos(0.2)                                  
   


acosh(num)
══════════════════════════════════════════════════════════════════════
  Returns the hyperbolic arccosine of a number
Parameter
  num   A number that is one or more
See Also
  abs(), acos(), asin(), asinh(), atan(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the hyperbolic arccosine of 1.2:
   ;SELECT acosh(1.2)                                 
   


asin(num)
══════════════════════════════════════════════════════════════════════
  Returns the arcsine of a number, in radians
Parameter
  num   A sine value that is between -1 and 1
See Also
  abs(), acos(), acosh(), asinh(), atan(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the arcsine of 0.2:
   ;SELECT asin(0.2)                                  
   


asinh(num)
══════════════════════════════════════════════════════════════════════
  Returns the hyperbolic arcsine of a number
Parameter
  num   The number
See Also
  abs(), acos(), acosh(), asin(), atan(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the hyperbolic arcsine of 0.2:
   ;SELECT asinh(0.2)                                 
   


atan(num)
══════════════════════════════════════════════════════════════════════
  Returns the arctangent of a number, in radians
Parameter
  num   The number
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan2(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the arctangent of 0.2:
   ;SELECT atan(0.2)                                  
   


atan2(y, x)
══════════════════════════════════════════════════════════════════════
  Returns the angle in the plane between the positive X axis and the
  ray from (0, 0) to the point (x, y)
Parameters
  y   The y coordinate of the point
  x   The x coordinate of the point
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atanh(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the angle, in degrees, for the point at (5, 5):
   ;SELECT degrees(atan2(5, 5))                       
   


atanh(num)
══════════════════════════════════════════════════════════════════════
  Returns the hyperbolic arctangent of a number
Parameter
  num   The number
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atn2(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the hyperbolic arctangent of 0.2:
   ;SELECT atanh(0.2)                                 
   


atn2(y, x)
══════════════════════════════════════════════════════════════════════
  Returns the angle in the plane between the positive X axis and the
  ray from (0, 0) to the point (x, y)
Parameters
  y   The y coordinate of the point
  x   The x coordinate of the point
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  avg(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the angle, in degrees, for the point at (5, 5):
   ;SELECT degrees(atn2(5, 5))                        
   


avg(X)
══════════════════════════════════════════════════════════════════════
  Returns the average value of all non-NULL numbers within a group.
Parameter
  X   The value to compute the average of.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), ceil(), degrees(), exp(), floor(), log(), log10(), max(), 
  min(), pi(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Examples
#1 To get the average of the column 'ex_duration' from the table 'lnav_example_log':
   ;SELECT avg(ex_duration) FROM lnav_example_log     
   

#2 To get the average of the column 'ex_duration' from the table 'lnav_example_log'
   when grouped by 'ex_procname':
   ;SELECT ex_procname, avg(ex_duration) FROM lnav_example_log GROUP BY ex_procname
   


basename(path)
══════════════════════════════════════════════════════════════════════
  Extract the base portion of a pathname.
Parameter
  path   The path
See Also
  dirname(), joinpath(), readlink(), realpath()
Examples
#1 To get the base of a plain file name:
   ;SELECT basename('foobar')                         
   

#2 To get the base of a path:
   ;SELECT basename('foo/bar')                        
   

#3 To get the base of a directory:
   ;SELECT basename('foo/bar/')                       
   

#4 To get the base of an empty string:
   ;SELECT basename('')                               
   

#5 To get the base of a Windows path:
   ;SELECT basename('foo\bar')                        
   

#6 To get the base of the root directory:
   ;SELECT basename('/')                              
   


ceil(num)
══════════════════════════════════════════════════════════════════════
  Returns the smallest integer that is not less than the argument
Parameter
  num   The number to raise to the ceiling
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), degrees(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the ceiling of 1.23:
   ;SELECT ceil(1.23)                                 
   


changes()
══════════════════════════════════════════════════════════════════════
  The number of database rows that were changed, inserted, or deleted
  by the most recent statement.


char(X, ...)
══════════════════════════════════════════════════════════════════════
  Returns a string composed of characters having the given unicode
  code point values
Parameter
  X   The unicode code point values
See Also
  charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), unicode(), upper(), xpath()
Example
#1 To get a string with the code points 0x48 and 0x49:
   ;SELECT char(0x48, 0x49)                           
   


charindex(needle, haystack, [start])
══════════════════════════════════════════════════════════════════════
  Finds the first occurrence of the needle within the haystack and
  returns the number of prior characters plus 1, or 0 if Y is nowhere
  found within X
Parameters
  needle     The string to look for in the haystack
  haystack   The string to search within
  start      The one-based index within the haystack to
             start the search
See Also
  char(), endswith(), extract(), group_concat(), group_spooky_hash(), 
  gunzip(), gzip(), humanize_file_size(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To search for the string 'abc' within 'abcabc' and starting at position 2:
   ;SELECT charindex('abc', 'abcabc', 2)              
   

#2 To search for the string 'abc' within 'abcdef' and starting at position 2:
   ;SELECT charindex('abc', 'abcdef', 2)              
   


coalesce(X, Y, ...)
══════════════════════════════════════════════════════════════════════
  Returns a copy of its first non-NULL argument, or NULL if all
  arguments are NULL
Parameters
  X   A value to check for NULL-ness
  Y   A value to check for NULL-ness

Example
#1 To get the first non-null value from three parameters:
   ;SELECT coalesce(null, 0, null)                    
   


count(X)
══════════════════════════════════════════════════════════════════════
  If the argument is '*', the total number of rows in the group is
  returned.  Otherwise, the number of times the argument is non-NULL.
Parameter
  X   The value to count.

Examples
#1 To get the count of the non-NULL rows of 'lnav_example_log':
   ;SELECT count(*) FROM lnav_example_log             
   

#2 To get the count of the non-NULL values of 'log_part' from 'lnav_example_log':
   ;SELECT count(log_part) FROM lnav_example_log      
   


cume_dist()
══════════════════════════════════════════════════════════════════════
  Returns the cumulative distribution
See Also
  dense_rank(), first_value(), lag(), last_value(), lead(), nth_value(), 
  ntile(), percent_rank(), rank(), row_number()

date(timestring, modifier, ...)
══════════════════════════════════════════════════════════════════════
  Returns the date in this format: YYYY-MM-DD.
Parameters
  timestring   The string to convert to a date.
  modifier     A transformation that is applied to the
               value to the left.
See Also
  datetime(), julianday(), strftime(), time(), timediff(), timeslice()
Examples
#1 To get the date portion of the timestamp '2017-01-02T03:04:05':
   ;SELECT date('2017-01-02T03:04:05')                
   

#2 To get the date portion of the timestamp '2017-01-02T03:04:05' plus one day:
   ;SELECT date('2017-01-02T03:04:05', '+1 day')      
   

#3 To get the date portion of the epoch timestamp 1491341842:
   ;SELECT date(1491341842, 'unixepoch')              
   


datetime(timestring, modifier, ...)
══════════════════════════════════════════════════════════════════════
  Returns the date and time in this format: YYYY-MM-DD HH:MM:SS.
Parameters
  timestring   The string to convert to a date with time.
  modifier     A transformation that is applied to the
               value to the left.
See Also
  date(), julianday(), strftime(), time(), timediff(), timeslice()
Examples
#1 To get the date and time portion of the timestamp '2017-01-02T03:04:05':
   ;SELECT datetime('2017-01-02T03:04:05')            
   

#2 To get the date and time portion of the timestamp '2017-01-02T03:04:05' plus one
   minute:
   ;SELECT datetime('2017-01-02T03:04:05', '+1 minute')
   

#3 To get the date and time portion of the epoch timestamp 1491341842:
   ;SELECT datetime(1491341842, 'unixepoch')          
   


degrees(radians)
══════════════════════════════════════════════════════════════════════
  Converts radians to degrees
Parameter
  radians   The radians value to convert to degrees
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), exp(), floor(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To convert PI to degrees:
   ;SELECT degrees(pi())                              
   


dense_rank()
══════════════════════════════════════════════════════════════════════
  Returns the row_number() of the first peer in each group without
  gaps
See Also
  cume_dist(), first_value(), lag(), last_value(), lead(), nth_value(), 
  ntile(), percent_rank(), rank(), row_number()

dirname(path)
══════════════════════════════════════════════════════════════════════
  Extract the directory portion of a pathname.
Parameter
  path   The path
See Also
  basename(), joinpath(), readlink(), realpath()
Examples
#1 To get the directory of a relative file path:
   ;SELECT dirname('foo/bar')                         
   

#2 To get the directory of an absolute file path:
   ;SELECT dirname('/foo/bar')                        
   

#3 To get the directory of a file in the root directory:
   ;SELECT dirname('/bar')                            
   

#4 To get the directory of a Windows path:
   ;SELECT dirname('foo\bar')                         
   

#5 To get the directory of an empty path:
   ;SELECT dirname('')                                
   


endswith(str, suffix)
══════════════════════════════════════════════════════════════════════
  Test if a string ends with the given suffix
Parameters
  str      The string to test
  suffix   The suffix to check in the string
See Also
  char(), charindex(), extract(), group_concat(), group_spooky_hash(), 
  gunzip(), gzip(), humanize_file_size(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To test if the string 'notbad.jpg' ends with '.jpg':
   ;SELECT endswith('notbad.jpg', '.jpg')             
   

#2 To test if the string 'notbad.png' starts with '.jpg':
   ;SELECT endswith('notbad.png', '.jpg')             
   


exp(x)
══════════════════════════════════════════════════════════════════════
  Returns the value of e raised to the power of x
Parameter
  x   The exponent
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), floor(), log(), log10(), max(), 
  min(), pi(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Example
#1 To raise e to 2:
   ;SELECT exp(2)                                     
   


extract(str)
══════════════════════════════════════════════════════════════════════
  Automatically Parse and extract data from a string
Parameter
  str   The string to parse
See Also
  char(), charindex(), endswith(), group_concat(), group_spooky_hash(), 
  gunzip(), gzip(), humanize_file_size(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To extract key/value pairs from a string:
   ;SELECT extract('foo=1 bar=2 name="Rolo Tomassi"') 
   

#2 To extract columnar data from a string:
   ;SELECT extract('1.0 abc 2.0')                     
   


first_value(expr)
══════════════════════════════════════════════════════════════════════
  Returns the result of evaluating the expression against the first
  row in the window frame.
Parameter
  expr   The expression to execute over the first row
See Also
  cume_dist(), dense_rank(), lag(), last_value(), lead(), nth_value(), 
  ntile(), percent_rank(), rank(), row_number()

floor(num)
══════════════════════════════════════════════════════════════════════
  Returns the largest integer that is not greater than the argument
Parameter
  num   The number to lower to the floor
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), log(), log10(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the floor of 1.23:
   ;SELECT floor(1.23)                                
   


generate_series(start, stop, [step])
══════════════════════════════════════════════════════════════════════
  A table-valued-function that returns the whole numbers between a
  lower and upper bound, inclusive
Parameters
  start   The starting point of the series
  stop    The stopping point of the series
  step    The increment between each value
Result
  value   The number in the series

Examples
#1 To generate the numbers in the range [10, 14]:
   ;SELECT value FROM generate_series(10, 14)         
   

#2 To generate every other number in the range [10, 14]:
   ;SELECT value FROM generate_series(10, 14, 2)      
   

#3 To count down from five to 1:
   ;SELECT value FROM generate_series(1, 5, -1)       
   


gethostbyaddr(hostname)
══════════════════════════════════════════════════════════════════════
  Get the hostname for the given IP address
Parameter
  hostname   The IP address to lookup.
See Also
  gethostbyname()
Example
#1 To get the hostname for the IP '127.0.0.1':
   ;SELECT gethostbyaddr('127.0.0.1')                 
   


gethostbyname(hostname)
══════════════════════════════════════════════════════════════════════
  Get the IP address for the given hostname
Parameter
  hostname   The DNS hostname to lookup.
See Also
  gethostbyaddr()
Example
#1 To get the IP address for 'localhost':
   ;SELECT gethostbyname('localhost')                 
   


glob(pattern, str)
══════════════════════════════════════════════════════════════════════
  Match a string against Unix glob pattern
Parameters
  pattern   The glob pattern
  str       The string to match

Example
#1 To test if the string 'abc' matches the glob 'a*':
   ;SELECT glob('a*', 'abc')                          
   


group_concat(X, [sep])
══════════════════════════════════════════════════════════════════════
  Returns a string which is the concatenation of all non-NULL values
  of X separated by a comma or the given separator.
Parameters
  X     The value to concatenate.
  sep   The separator to place between the values.
See Also
  char(), charindex(), endswith(), extract(), group_spooky_hash(), 
  gunzip(), gzip(), humanize_file_size(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To concatenate the values of the column 'ex_procname' from the table
   'lnav_example_log':
   ;SELECT group_concat(ex_procname) FROM lnav_example_log
   

#2 To join the values of the column 'ex_procname' using the string ', ':
   ;SELECT group_concat(ex_procname, ', ') FROM lnav_example_log
   

#3 To concatenate the distinct values of the column 'ex_procname' from the table
   'lnav_example_log':
   ;SELECT group_concat(DISTINCT ex_procname) FROM lnav_example_log
   


group_spooky_hash(str, ...)
══════════════════════════════════════════════════════════════════════
  Compute the hash value for the given arguments
Parameter
  str   The string to hash
See Also
  char(), charindex(), endswith(), extract(), group_concat(), gunzip(), 
  gzip(), humanize_file_size(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To produce a hash of all of the values of 'column1':
   ;SELECT group_spooky_hash(column1) FROM (VALUES ('abc'), ('123'))
   


gunzip(b, ...)
══════════════════════════════════════════════════════════════════════
  Decompress a gzip file
Parameter
  b   The blob to decompress
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gzip(), humanize_file_size(), instr(), leftstr(), 
  length(), logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()

gzip(value, ...)
══════════════════════════════════════════════════════════════════════
  Compress a string into a gzip file
Parameter
  value   The value to compress
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), unicode(), upper(), xpath()

hex(X)
══════════════════════════════════════════════════════════════════════
  Returns a string which is the upper-case hexadecimal rendering of
  the content of its argument.
Parameter
  X   The blob to convert to hexadecimal

Example
#1 To get the hexadecimal rendering of the string 'abc':
   ;SELECT hex('abc')                                 
   


humanize_file_size(value)
══════════════════════════════════════════════════════════════════════
  Format the given file size as a human-friendly string
Parameter
  value   The file size to format
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), instr(), leftstr(), length(), 
  logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), printf(), 
  proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To format an amount:
   ;SELECT humanize_file_size(10 * 1024 * 1024)       
   


ifnull(X, Y)
══════════════════════════════════════════════════════════════════════
  Returns a copy of its first non-NULL argument, or NULL if both
  arguments are NULL
Parameters
  X   A value to check for NULL-ness
  Y   A value to check for NULL-ness

Example
#1 To get the first non-null value between null and zero:
   ;SELECT ifnull(null, 0)                            
   


instr(haystack, needle)
══════════════════════════════════════════════════════════════════════
  Finds the first occurrence of the needle within the haystack and
  returns the number of prior characters plus 1, or 0 if the needle
  was not found
Parameters
  haystack   The string to search within
  needle     The string to look for in the haystack
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), leftstr(), 
  length(), logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To test get the position of 'b' in the string 'abc':
   ;SELECT instr('abc', 'b')                          
   


jget(json, ptr, [default])
══════════════════════════════════════════════════════════════════════
  Get the value from a JSON object using a JSON-Pointer.
Parameters
  json      The JSON object to query.
  ptr       The JSON-Pointer to lookup in the object.
  default   The default value if the value was not found
See Also
  json_concat(), json_contains(), json_group_array(), 
  json_group_object()
Examples
#1 To get the root of a JSON value:
   ;SELECT jget('1', '')                              
   

#2 To get the property named 'b' in a JSON object:
   ;SELECT jget('{ "a": 1, "b": 2 }', '/b')           
   

#3 To get the 'msg' property and return a default if it does not exist:
   ;SELECT jget(null, '/msg', 'Hello')                
   


joinpath(path, ...)
══════════════════════════════════════════════════════════════════════
  Join components of a path together.
Parameter
  path   One or more path components to join together.  If an
         argument starts with a forward or backward slash, it will be
         considered an absolute path and any preceding elements will
         be ignored.
See Also
  basename(), dirname(), readlink(), realpath()
Examples
#1 To join a directory and file name into a relative path:
   ;SELECT joinpath('foo', 'bar')                     
   

#2 To join an empty component with other names into a relative path:
   ;SELECT joinpath('', 'foo', 'bar')                 
   

#3 To create an absolute path with two path components:
   ;SELECT joinpath('/', 'foo', 'bar')                
   

#4 To create an absolute path from a path component that starts with a forward slash:
   ;SELECT joinpath('/', 'foo', '/bar')               
   


json_concat(json, value, ...)
══════════════════════════════════════════════════════════════════════
  Returns an array with the given values concatenated onto the end.
  If the initial value is null, the result will be an array with the
  given elements.  If the initial value is an array, the result will
  be an array with the given values at the end.  If the initial value
  is not null or an array, the result will be an array with two
  elements: the initial value and the given value.
Parameters
  json    The initial JSON value.
  value   The value(s) to add to the end of the array.
See Also
  jget(), json_contains(), json_group_array(), json_group_object()
Examples
#1 To append the number 4 to null:
   ;SELECT json_concat(NULL, 4)                       
   

#2 To append 4 and 5 to the array [1, 2, 3]:
   ;SELECT json_concat('[1, 2, 3]', 4, 5)             
   

#3 To concatenate two arrays together:
   ;SELECT json_concat('[1, 2, 3]', json('[4, 5]'))   
   


json_contains(json, value)
══════════════════════════════════════════════════════════════════════
  Check if a JSON value contains the given element.
Parameters
  json    The JSON value to query.
  value   The value to look for in the first argument
See Also
  jget(), json_concat(), json_group_array(), json_group_object()
Examples
#1 To test if a JSON array contains the number 4:
   ;SELECT json_contains('[1, 2, 3]', 4)              
   

#2 To test if a JSON array contains the string 'def':
   ;SELECT json_contains('["abc", "def"]', 'def')     
   


json_group_array(value, ...)
══════════════════════════════════════════════════════════════════════
  Collect the given values from a query into a JSON array
Parameter
  value   The values to append to the array
See Also
  jget(), json_concat(), json_contains(), json_group_object()
Examples
#1 To create an array from arguments:
   ;SELECT json_group_array('one', 2, 3.4)            
   

#2 To create an array from a column of values:
   ;SELECT json_group_array(column1) FROM (VALUES (1), (2), (3))
   


json_group_object(name, value, ...)
══════════════════════════════════════════════════════════════════════
  Collect the given values from a query into a JSON object
Parameters
  name    The property name for the value
  value   The value to add to the object
See Also
  jget(), json_concat(), json_contains(), json_group_array()
Examples
#1 To create an object from arguments:
   ;SELECT json_group_object('a', 1, 'b', 2)          
   

#2 To create an object from a pair of columns:
   ;SELECT json_group_object(column1, column2) FROM (VALUES ('a', 1), ('b', 2))
   


julianday(timestring, modifier, ...)
══════════════════════════════════════════════════════════════════════
  Returns the number of days since noon in Greenwich on November 24,
  4714 B.C.
Parameters
  timestring   The string to convert to a date with time.
  modifier     A transformation that is applied to the
               value to the left.
See Also
  date(), datetime(), strftime(), time(), timediff(), timeslice()
Examples
#1 To get the julian day from the timestamp '2017-01-02T03:04:05':
   ;SELECT julianday('2017-01-02T03:04:05')           
   

#2 To get the julian day from the timestamp '2017-01-02T03:04:05' plus one minute:
   ;SELECT julianday('2017-01-02T03:04:05', '+1 minute')
   

#3 To get the julian day from the timestamp 1491341842:
   ;SELECT julianday(1491341842, 'unixepoch')         
   


lag(expr, [offset], [default])
══════════════════════════════════════════════════════════════════════
  Returns the result of evaluating the expression against the previous
  row in the partition.
Parameters
  expr      The expression to execute over the previous row
  offset    The offset from the current row in the partition
  default   The default value if the previous row does not
            exist instead of NULL
See Also
  cume_dist(), dense_rank(), first_value(), last_value(), lead(), 
  nth_value(), ntile(), percent_rank(), rank(), row_number()

last_insert_rowid()
══════════════════════════════════════════════════════════════════════
  Returns the ROWID of the last row insert from the database
  connection which invoked the function


last_value(expr)
══════════════════════════════════════════════════════════════════════
  Returns the result of evaluating the expression against the last row
  in the window frame.
Parameter
  expr   The expression to execute over the last row
See Also
  cume_dist(), dense_rank(), first_value(), lag(), lead(), nth_value(), 
  ntile(), percent_rank(), rank(), row_number()

lead(expr, [offset], [default])
══════════════════════════════════════════════════════════════════════
  Returns the result of evaluating the expression against the next row
  in the partition.
Parameters
  expr      The expression to execute over the next row
  offset    The offset from the current row in the partition
  default   The default value if the next row does not exist
            instead of NULL
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), 
  nth_value(), ntile(), percent_rank(), rank(), row_number()

leftstr(str, N)
══════════════════════════════════════════════════════════════════════
  Returns the N leftmost (UTF-8) characters in the given string.
Parameters
  str   The string to return subset.
  N     The number of characters from the left side of the
        string to return.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  length(), logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To get the first character of the string 'abc':
   ;SELECT leftstr('abc', 1)                          
   

#2 To get the first ten characters of a string, regardless of size:
   ;SELECT leftstr('abc', 10)                         
   


length(str)
══════════════════════════════════════════════════════════════════════
  Returns the number of characters (not bytes) in the given string
  prior to the first NUL character
Parameter
  str   The string to determine the length of
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), logfmt2json(), lower(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To get the length of the string 'abc':
   ;SELECT length('abc')                              
   


like(pattern, str, [escape])
══════════════════════════════════════════════════════════════════════
  Match a string against a pattern
Parameters
  pattern   The pattern to match.  A percent symbol (%) will
            match zero or more characters and an underscore (_) will
            match a single character.
  str       The string to match
  escape    The escape character that can be used to prefix
            a literal percent or underscore in the pattern.

Examples
#1 To test if the string 'aabcc' contains the letter 'b':
   ;SELECT like('%b%', 'aabcc')                       
   

#2 To test if the string 'aab%' ends with 'b%':
   ;SELECT like('%b:%', 'aab%', ':')                  
   


likelihood(value, probability)
══════════════════════════════════════════════════════════════════════
  Provides a hint to the query planner that the first argument is a
  boolean that is true with the given probability
Parameters
  value         The boolean value to return
  probability   A floating point constant between 0.0
                and 1.0


likely(value)
══════════════════════════════════════════════════════════════════════
  Short-hand for likelihood(X,0.9375)
Parameter
  value   The boolean value to return


lnav_top_file()
══════════════════════════════════════════════════════════════════════
  Return the name of the file that the top line in the current view
  came from.


lnav_version()
══════════════════════════════════════════════════════════════════════
  Return the current version of lnav


load_extension(path, [entry-point])
══════════════════════════════════════════════════════════════════════
  Loads SQLite extensions out of the given shared library file using
  the given entry point.
Parameters
  path          The path to the shared library
                containing the extension.
  entry-point   


log(x)
══════════════════════════════════════════════════════════════════════
  Returns the natural logarithm of x
Parameter
  x   The number
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log10(), max(), 
  min(), pi(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Example
#1 To get the natual logarithm of 8:
   ;SELECT log(8)                                     
   


log10(x)
══════════════════════════════════════════════════════════════════════
  Returns the base-10 logarithm of X
Parameter
  x   The number
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), max(), min(), 
  pi(), power(), radians(), round(), sign(), square(), sum(), total()
Example
#1 To get the logarithm of 100:
   ;SELECT log10(100)                                 
   


log_top_datetime()
══════════════════════════════════════════════════════════════════════
  Return the timestamp of the line at the top of the log view.


log_top_line()
══════════════════════════════════════════════════════════════════════
  Return the line number at the top of the log view.


logfmt2json(str)
══════════════════════════════════════════════════════════════════════
  Convert a logfmt-encoded string into JSON
Parameter
  str   The logfmt message to parse
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), lower(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To extract key/value pairs from a log message:
   ;SELECT logfmt2json('foo=1 bar=2 name="Rolo Tomassi"')
   


lower(str)
══════════════════════════════════════════════════════════════════════
  Returns a copy of the given string with all ASCII characters
  converted to lower case.
Parameter
  str   The string to convert.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), ltrim(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To lowercase the string 'AbC':
   ;SELECT lower('AbC')                               
   


ltrim(str, [chars])
══════════════════════════════════════════════════════════════════════
  Returns a string formed by removing any and all characters that
  appear in the second argument from the left side of the first.
Parameters
  str     The string to trim characters from the left side
  chars   The characters to trim.  Defaults to spaces.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), padc(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To trim the leading whitespace from the string '   abc':
   ;SELECT ltrim('   abc')                            
   

#2 To trim the characters 'a' or 'b' from the left side of the string 'aaaabbbc':
   ;SELECT ltrim('aaaabbbc', 'ab')                    
   


max(X, ...)
══════════════════════════════════════════════════════════════════════
  Returns the argument with the maximum value, or return NULL if any
  argument is NULL.
Parameter
  X   The numbers to find the maximum of.  If only one argument is
      given, this function operates as an aggregate.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  min(), pi(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Examples
#1 To get the largest value from the parameters:
   ;SELECT max(2, 1, 3)                               
   

#2 To get the largest value from an aggregate:
   ;SELECT max(status) FROM http_status_codes         
   


min(X, ...)
══════════════════════════════════════════════════════════════════════
  Returns the argument with the minimum value, or return NULL if any
  argument is NULL.
Parameter
  X   The numbers to find the minimum of.  If only one argument is
      given, this function operates as an aggregate.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), pi(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Examples
#1 To get the smallest value from the parameters:
   ;SELECT min(2, 1, 3)                               
   

#2 To get the smallest value from an aggregate:
   ;SELECT min(status) FROM http_status_codes         
   


nth_value(expr, N)
══════════════════════════════════════════════════════════════════════
  Returns the result of evaluating the expression against the nth row
  in the window frame.
Parameters
  expr   The expression to execute over the nth row
  N      The row number
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), lead(), 
  ntile(), percent_rank(), rank(), row_number()

ntile(groups)
══════════════════════════════════════════════════════════════════════
  Returns the number of the group that the current row is a part of
Parameter
  groups   The number of groups
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), lead(), 
  nth_value(), percent_rank(), rank(), row_number()

nullif(X, Y)
══════════════════════════════════════════════════════════════════════
  Returns its first argument if the arguments are different and NULL
  if the arguments are the same.
Parameters
  X   The first argument to compare.
  Y   The argument to compare against the first.

Examples
#1 To test if 1 is different from 1:
   ;SELECT nullif(1, 1)                               
   

#2 To test if 1 is different from 2:
   ;SELECT nullif(1, 2)                               
   


padc(str, len)
══════════════════════════════════════════════════════════════════════
  Pad the given string with enough spaces to make it centered within
  the given length
Parameters
  str   The string to pad
  len   The minimum desired length of the output string
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padl(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To pad the string 'abc' to a length of six characters:
   ;SELECT padc('abc', 6) || 'def'                    
   

#2 To pad the string 'abcdef' to a length of eight characters:
   ;SELECT padc('abcdef', 8) || 'ghi'                 
   


padl(str, len)
══════════════════════════════════════════════════════════════════════
  Pad the given string with leading spaces until it reaches the
  desired length
Parameters
  str   The string to pad
  len   The minimum desired length of the output string
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padr(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To pad the string 'abc' to a length of six characters:
   ;SELECT padl('abc', 6)                             
   

#2 To pad the string 'abcdef' to a length of four characters:
   ;SELECT padl('abcdef', 4)                          
   


padr(str, len)
══════════════════════════════════════════════════════════════════════
  Pad the given string with trailing spaces until it reaches the
  desired length
Parameters
  str   The string to pad
  len   The minimum desired length of the output string
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  printf(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To pad the string 'abc' to a length of six characters:
   ;SELECT padr('abc', 6) || 'def'                    
   

#2 To pad the string 'abcdef' to a length of four characters:
   ;SELECT padr('abcdef', 4) || 'ghi'                 
   


percent_rank()
══════════════════════════════════════════════════════════════════════
  Returns (rank - 1) / (partition-rows - 1)
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), lead(), 
  nth_value(), ntile(), rank(), row_number()

pi()
══════════════════════════════════════════════════════════════════════
  Returns the value of PI
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), power(), radians(), round(), sign(), square(), sum(), 
  total()
Example
#1 To get the value of PI:
   ;SELECT pi()                                       
   


power(base, exp)
══════════════════════════════════════════════════════════════════════
  Returns the base to the given exponent
Parameters
  base   The base number
  exp    The exponent
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), radians(), round(), sign(), square(), sum(), 
  total()
Example
#1 To raise two to the power of three:
   ;SELECT power(2, 3)                                
   


printf(format, X)
══════════════════════════════════════════════════════════════════════
  Returns a string with this functions arguments substituted into the
  given format.  Substitution points are specified using percent (%)
  options, much like the standard C printf() function.
Parameters
  format   The format of the string to return.
  X        The argument to substitute at a given position in
           the format.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), proper(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Examples
#1 To substitute 'World' into the string 'Hello, %s!':
   ;SELECT printf('Hello, %s!', 'World')              
   

#2 To right-align 'small' in the string 'align:' with a column width of 10:
   ;SELECT printf('align: % 10s', 'small')            
   

#3 To format 11 with a width of five characters and leading zeroes:
   ;SELECT printf('value: %05d', 11)                  
   


proper(str)
══════════════════════════════════════════════════════════════════════
  Capitalize the first character of words in the given string
Parameter
  str   The string to capitalize.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), regexp_capture(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To capitalize the words in the string 'hello, world!':
   ;SELECT proper('hello, world!')                    
   


quote(X)
══════════════════════════════════════════════════════════════════════
  Returns the text of an SQL literal which is the value of its
  argument suitable for inclusion into an SQL statement.
Parameter
  X   The string to quote.

Examples
#1 To quote the string 'abc':
   ;SELECT quote('abc')                               
   

#2 To quote the string 'abc'123':
   ;SELECT quote('abc''123')                          
   


radians(degrees)
══════════════════════════════════════════════════════════════════════
  Converts degrees to radians
Parameter
  degrees   The degrees value to convert to radians
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), round(), sign(), square(), sum(), total()
Example
#1 To convert 180 degrees to radians:
   ;SELECT radians(180)                               
   


raise_error(msg)
══════════════════════════════════════════════════════════════════════
  Raises an error with the given message when executed
Parameter
  msg   The error message


random()
══════════════════════════════════════════════════════════════════════
  Returns a pseudo-random integer between -9223372036854775808 and
  +9223372036854775807.


randomblob(N)
══════════════════════════════════════════════════════════════════════
  Return an N-byte blob containing pseudo-random bytes.
Parameter
  N   The size of the blob in bytes.


rank()
══════════════════════════════════════════════════════════════════════
  Returns the row_number() of the first peer in each group with gaps
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), lead(), 
  nth_value(), ntile(), percent_rank(), row_number()

readlink(path)
══════════════════════════════════════════════════════════════════════
  Read the target of a symbolic link.
Parameter
  path   The path to the symbolic link.
See Also
  basename(), dirname(), joinpath(), realpath()

realpath(path)
══════════════════════════════════════════════════════════════════════
  Returns the resolved version of the given path, expanding symbolic
  links and resolving '.' and '..' references.
Parameter
  path   The path to resolve.
See Also
  basename(), dirname(), joinpath(), readlink()

regexp(re, str)
══════════════════════════════════════════════════════════════════════
  Test if a string matches a regular expression
Parameters
  re    The regular expression to use
  str   The string to test against the regular expression


regexp_capture(string, pattern)
══════════════════════════════════════════════════════════════════════
  A table-valued function that executes a regular-expression over a
  string and returns the captured values.  If the regex only matches a
  subset of the input string, it will be rerun on the remaining parts
  of the string until no more matches are found.
Parameters
  string    The string to match against the given pattern.
  pattern   The regular expression to match.
Results
  match_index     The match iteration.  This value
                  will increase each time a new match is found in the
                  input string.
  capture_index   The index of the capture in the
                  regex.
  capture_name    The name of the capture in the
                  regex.
  capture_count   The total number of captures in the
                  regex.
  range_start     The start of the capture in the
                  input string.
  range_stop      The stop of the capture in the input
                  string.
  content         The captured value from the string.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_match(), regexp_replace(), 
  replace(), replicate(), reverse(), rightstr(), rtrim(), sparkline(), 
  spooky_hash(), startswith(), strfilter(), substr(), trim(), unicode(), 
  upper(), xpath()
Example
#1 To extract the key/value pairs 'a'/1 and 'b'/2 from the string 'a=1; b=2':
   ;SELECT * FROM regexp_capture('a=1; b=2', '(\w+)=(\d+)')
   


regexp_match(re, str)
══════════════════════════════════════════════════════════════════════
  Match a string against a regular expression and return the capture
  groups as JSON.
Parameters
  re    The regular expression to use
  str   The string to test against the regular expression
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_replace(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), unicode(), upper(), xpath()
Examples
#1 To capture the digits from the string '123':
   ;SELECT regexp_match('(\d+)', '123')               
   

#2 To capture a number and word into a JSON object with the properties 'col_0' and
   'col_1':
   ;SELECT regexp_match('(\d+) (\w+)', '123 four')    
   

#3 To capture a number and word into a JSON object with the named properties 'num' and
   'str':
   ;SELECT regexp_match('(?<num>\d+) (?<str>\w+)', '123 four')
   


regexp_replace(str, re, repl)
══════════════════════════════════════════════════════════════════════
  Replace the parts of a string that match a regular expression.
Parameters
  str    The string to perform replacements on
  re     The regular expression to match
  repl   The replacement string.  You can reference capture
         groups with a backslash followed by the number of the group,
         starting with 1.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_match(), replace(), replicate(), reverse(), rightstr(), rtrim(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Examples
#1 To replace the word at the start of the string 'Hello, World!' with 'Goodbye':
   ;SELECT regexp_replace('Hello, World!', '^(\w+)', 'Goodbye')
   

#2 To wrap alphanumeric words with angle brackets:
   ;SELECT regexp_replace('123 abc', '(\w+)', '<\1>') 
   


replace(str, old, replacement)
══════════════════════════════════════════════════════════════════════
  Returns a string formed by substituting the replacement string for
  every occurrence of the old string in the given string.
Parameters
  str           The string to perform substitutions on.
  old           The string to be replaced.
  replacement   The string to replace any occurrences of
                the old string with.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replicate(), reverse(), rightstr(), rtrim(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Examples
#1 To replace the string 'x' with 'z' in 'abc':
   ;SELECT replace('abc', 'x', 'z')                   
   

#2 To replace the string 'a' with 'z' in 'abc':
   ;SELECT replace('abc', 'a', 'z')                   
   


replicate(str, N)
══════════════════════════════════════════════════════════════════════
  Returns the given string concatenated N times.
Parameters
  str   The string to replicate.
  N     The number of times to replicate the string.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), reverse(), rightstr(), rtrim(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Example
#1 To repeat the string 'abc' three times:
   ;SELECT replicate('abc', 3)                        
   


reverse(str)
══════════════════════════════════════════════════════════════════════
  Returns the reverse of the given string.
Parameter
  str   The string to reverse.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), rightstr(), rtrim(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Example
#1 To reverse the string 'abc':
   ;SELECT reverse('abc')                             
   


rightstr(str, N)
══════════════════════════════════════════════════════════════════════
  Returns the N rightmost (UTF-8) characters in the given string.
Parameters
  str   The string to return subset.
  N     The number of characters from the right side of the
        string to return.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rtrim(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Examples
#1 To get the last character of the string 'abc':
   ;SELECT rightstr('abc', 1)                         
   

#2 To get the last ten characters of a string, regardless of size:
   ;SELECT rightstr('abc', 10)                        
   


round(num, [digits])
══════════════════════════════════════════════════════════════════════
  Returns a floating-point value rounded to the given number of digits
  to the right of the decimal point.
Parameters
  num      The value to round.
  digits   The number of digits to the right of the decimal
           to round to.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), radians(), sign(), square(), sum(), 
  total()
Examples
#1 To round the number 123.456 to an integer:
   ;SELECT round(123.456)                             
   

#2 To round the number 123.456 to a precision of 1:
   ;SELECT round(123.456, 1)                          
   

#3 To round the number 123.456 to a precision of 5:
   ;SELECT round(123.456, 5)                          
   


row_number()
══════════════════════════════════════════════════════════════════════
  Returns the number of the row within the current partition, starting
  from 1.
See Also
  cume_dist(), dense_rank(), first_value(), lag(), last_value(), lead(), 
  nth_value(), ntile(), percent_rank(), rank()
Example
#1 To number messages from a process:
   ;SELECT row_number() OVER (PARTITION BY ex_procname ORDER BY log_line) AS msg_num,
      ex_procname, log_body FROM lnav_example_log
   


rtrim(str, [chars])
══════════════════════════════════════════════════════════════════════
  Returns a string formed by removing any and all characters that
  appear in the second argument from the right side of the first.
Parameters
  str     The string to trim characters from the right side
  chars   The characters to trim.  Defaults to spaces.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  sparkline(), spooky_hash(), startswith(), strfilter(), substr(), 
  trim(), unicode(), upper(), xpath()
Examples
#1 To trim the whitespace from the end of the string 'abc   ':
   ;SELECT rtrim('abc   ')                            
   

#2 To trim the characters 'b' and 'c' from the string 'abbbbcccc':
   ;SELECT rtrim('abbbbcccc', 'bc')                   
   


sign(num)
══════════════════════════════════════════════════════════════════════
  Returns the sign of the given number as -1, 0, or 1
Parameter
  num   The number
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), radians(), round(), square(), sum(), 
  total()
Examples
#1 To get the sign of 10:
   ;SELECT sign(10)                                   
   

#2 To get the sign of 0:
   ;SELECT sign(0)                                    
   

#3 To get the sign of -10:
   ;SELECT sign(-10)                                  
   


sparkline(value, [upper])
══════════════════════════════════════════════════════════════════════
  Function used to generate a sparkline bar chart.  The non-aggregate
  version converts a single numeric value on a range to a bar chart
  character.  The aggregate version returns a string with a bar
  character for every numeric input
Parameters
  value   The numeric value to convert
  upper   The upper bound of the numeric range.  The
          non-aggregate version defaults to 100.  The aggregate
          version uses the largest value in the inputs.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), spooky_hash(), startswith(), strfilter(), substr(), trim(), 
  unicode(), upper(), xpath()
Examples
#1 To get the unicode block element for the value 32 in the range of 0-128:
   ;SELECT sparkline(32, 128)                         
   

#2 To chart the values in a JSON array:
   ;SELECT sparkline(value) FROM json_each('[0, 1, 2, 3, 4, 5, 6, 7, 8]')
   


spooky_hash(str, ...)
══════════════════════════════════════════════════════════════════════
  Compute the hash value for the given arguments.
Parameter
  str   The string to hash
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), startswith(), strfilter(), substr(), trim(), 
  unicode(), upper(), xpath()
Examples
#1 To produce a hash for the string 'Hello, World!':
   ;SELECT spooky_hash('Hello, World!')               
   

#2 To produce a hash for the parameters where one is NULL:
   ;SELECT spooky_hash('Hello, World!', NULL)         
   

#3 To produce a hash for the parameters where one is an empty string:
   ;SELECT spooky_hash('Hello, World!', '')           
   

#4 To produce a hash for the parameters where one is a number:
   ;SELECT spooky_hash('Hello, World!', 123)          
   


sqlite_compileoption_get(N)
══════════════════════════════════════════════════════════════════════
  Returns the N-th compile-time option used to build SQLite or NULL if
  N is out of range.
Parameter
  N   The option number to get


sqlite_compileoption_used(option)
══════════════════════════════════════════════════════════════════════
  Returns true (1) or false (0) depending on whether or not that
  compile-time option was used during the build.
Parameter
  option   The name of the compile-time option.

Example
#1 To check if the SQLite library was compiled with ENABLE_FTS3:
   ;SELECT sqlite_compileoption_used('ENABLE_FTS3')   
   


sqlite_source_id()
══════════════════════════════════════════════════════════════════════
  Returns a string that identifies the specific version of the source
  code that was used to build the SQLite library.


sqlite_version()
══════════════════════════════════════════════════════════════════════
  Returns the version string for the SQLite library that is running.


square(num)
══════════════════════════════════════════════════════════════════════
  Returns the square of the argument
Parameter
  num   The number to square
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), radians(), round(), sign(), sum(), 
  total()
Example
#1 To get the square of two:
   ;SELECT square(2)                                  
   


startswith(str, prefix)
══════════════════════════════════════════════════════════════════════
  Test if a string begins with the given prefix
Parameters
  str      The string to test
  prefix   The prefix to check in the string
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), strfilter(), substr(), trim(), 
  unicode(), upper(), xpath()
Examples
#1 To test if the string 'foobar' starts with 'foo':
   ;SELECT startswith('foobar', 'foo')                
   

#2 To test if the string 'foobar' starts with 'bar':
   ;SELECT startswith('foobar', 'bar')                
   


strfilter(source, include)
══════════════════════════════════════════════════════════════════════
  Returns the source string with only the characters given in the
  second parameter
Parameters
  source    The string to filter
  include   The characters to include in the result
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), substr(), trim(), 
  unicode(), upper(), xpath()
Example
#1 To get the 'b', 'c', and 'd' characters from the string 'abcabc':
   ;SELECT strfilter('abcabc', 'bcd')                 
   


strftime(format, timestring, modifier, ...)
══════════════════════════════════════════════════════════════════════
  Returns the date formatted according to the format string specified
  as the first argument.
Parameters
  format       A format string with substitutions similar
               to those found in the strftime() standard C library.
  timestring   The string to convert to a date with time.
  modifier     A transformation that is applied to the
               value to the left.
See Also
  date(), datetime(), julianday(), time(), timediff(), timeslice()
Examples
#1 To get the year from the timestamp '2017-01-02T03:04:05':
   ;SELECT strftime('%Y', '2017-01-02T03:04:05')      
   

#2 To create a string with the time from the timestamp '2017-01-02T03:04:05' plus one
   minute:
   ;SELECT strftime('The time is: %H:%M:%S', '2017-01-02T03:04:05', '+1 minute')
   

#3 To create a string with the Julian day from the epoch timestamp 1491341842:
   ;SELECT strftime('Julian day: %J', 1491341842, 'unixepoch')
   


substr(str, start, [size])
══════════════════════════════════════════════════════════════════════
  Returns a substring of input string X that begins with the Y-th
  character and which is Z characters long.
Parameters
  str     The string to extract a substring from.
  start   The index within 'str' that is the start of the
          substring.  Indexes begin at 1.  A negative value means that
          the substring is found by counting from the right rather
          than the left.  
  size    The size of the substring.  If not given, then all
          characters through the end of the string are returned.  If
          the value is negative, then the characters before the start
          are returned.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), trim(), 
  unicode(), upper(), xpath()
Examples
#1 To get the substring starting at the second character until the end of the string
   'abc':
   ;SELECT substr('abc', 2)                           
   

#2 To get the substring of size one starting at the second character of the string
   'abc':
   ;SELECT substr('abc', 2, 1)                        
   

#3 To get the substring starting at the last character until the end of the string
   'abc':
   ;SELECT substr('abc', -1)                          
   

#4 To get the substring starting at the last character and going backwards one step of
   the string 'abc':
   ;SELECT substr('abc', -1, -1)                      
   


sum(X)
══════════════════════════════════════════════════════════════════════
  Returns the sum of the values in the group as an integer.
Parameter
  X   The values to add.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), radians(), round(), sign(), square(), 
  total()
Example
#1 To sum all of the values in the column 'ex_duration' from the table
   'lnav_example_log':
   ;SELECT sum(ex_duration) FROM lnav_example_log     
   


time(timestring, modifier, ...)
══════════════════════════════════════════════════════════════════════
  Returns the time in this format: HH:MM:SS.
Parameters
  timestring   The string to convert to a time.
  modifier     A transformation that is applied to the
               value to the left.
See Also
  date(), datetime(), julianday(), strftime(), timediff(), timeslice()
Examples
#1 To get the time portion of the timestamp '2017-01-02T03:04:05':
   ;SELECT time('2017-01-02T03:04:05')                
   

#2 To get the time portion of the timestamp '2017-01-02T03:04:05' plus one minute:
   ;SELECT time('2017-01-02T03:04:05', '+1 minute')   
   

#3 To get the time portion of the epoch timestamp 1491341842:
   ;SELECT time(1491341842, 'unixepoch')              
   


timediff(time1, time2)
══════════════════════════════════════════════════════════════════════
  Compute the difference between two timestamps in seconds
Parameters
  time1   The first timestamp
  time2   The timestamp to subtract from the first
See Also
  date(), datetime(), julianday(), strftime(), time(), timeslice()
Examples
#1 To get the difference between two timestamps:
   ;SELECT timediff('2017-02-03T04:05:06', '2017-02-03T04:05:00')
   

#2 To get the difference between relative timestamps:
   ;SELECT timediff('today', 'yesterday')             
   


timeslice(time, slice)
══════════════════════════════════════════════════════════════════════
  Return the start of the slice of time that the given timestamp falls
  in.  If the time falls outside of the slice, NULL is returned.
Parameters
  time    The timestamp to get the time slice for.
  slice   The size of the time slices
See Also
  date(), datetime(), julianday(), strftime(), time(), timediff()
Examples
#1 To get the timestamp rounded down to the start of the ten minute slice:
   ;SELECT timeslice('2017-01-01T05:05:00', '10m')    
   

#2 To group log messages into five minute buckets and count them:
   ;SELECT timeslice(log_time_msecs, '5m') AS slice, count(1)
          FROM lnav_example_log GROUP BY slice
   

#3 To group log messages by those before 4:30am and after:
   ;SELECT timeslice(log_time_msecs, 'before 4:30am') AS slice, count(1) FROM
      lnav_example_log GROUP BY slice
   


total(X)
══════════════════════════════════════════════════════════════════════
  Returns the sum of the values in the group as a floating-point.
Parameter
  X   The values to add.
See Also
  abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), 
  atn2(), avg(), ceil(), degrees(), exp(), floor(), log(), log10(), 
  max(), min(), pi(), power(), radians(), round(), sign(), square(), 
  sum()
Example
#1 To total all of the values in the column 'ex_duration' from the table
   'lnav_example_log':
   ;SELECT total(ex_duration) FROM lnav_example_log   
   


total_changes()
══════════════════════════════════════════════════════════════════════
  Returns the number of row changes caused by INSERT, UPDATE or DELETE
  statements since the current database connection was opened.


trim(str, [chars])
══════════════════════════════════════════════════════════════════════
  Returns a string formed by removing any and all characters that
  appear in the second argument from the left and right sides of the
  first.
Parameters
  str     The string to trim characters from the left and
          right sides.
  chars   The characters to trim.  Defaults to spaces.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), unicode(), upper(), xpath()
Examples
#1 To trim whitespace from the start and end of the string '    abc   ':
   ;SELECT trim('    abc   ')                         
   

#2 To trim the characters '-' and '+' from the string '-+abc+-':
   ;SELECT trim('-+abc+-', '-+')                      
   


typeof(X)
══════════════════════════════════════════════════════════════════════
  Returns a string that indicates the datatype of the expression X:
  "null", "integer", "real", "text", or "blob".
Parameter
  X   The expression to check.

Examples
#1 To get the type of the number 1:
   ;SELECT typeof(1)                                  
   

#2 To get the type of the string 'abc':
   ;SELECT typeof('abc')                              
   


unicode(X)
══════════════════════════════════════════════════════════════════════
  Returns the numeric unicode code point corresponding to the first
  character of the string X.
Parameter
  X   The string to examine.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), upper(), xpath()
Example
#1 To get the unicode code point for the first character of 'abc':
   ;SELECT unicode('abc')                             
   


unlikely(value)
══════════════════════════════════════════════════════════════════════
  Short-hand for likelihood(X, 0.0625)
Parameter
  value   The boolean value to return


upper(str)
══════════════════════════════════════════════════════════════════════
  Returns a copy of the given string with all ASCII characters
  converted to upper case.
Parameter
  str   The string to convert.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), unicode(), xpath()
Example
#1 To uppercase the string 'aBc':
   ;SELECT upper('aBc')                               
   


xpath(xpath, xmldoc)
══════════════════════════════════════════════════════════════════════
  A table-valued function that executes an xpath expression over an
  XML string and returns the selected values.
Parameters
  xpath    The XPATH expression to evaluate over the XML
           document.
  xmldoc   The XML document as a string.
Results
  result      The result of the XPATH expression.
  node_path   The absolute path to the node containing the
              result.
  node_attr   The node's attributes stored in JSON object.
  node_text   The node's text value.
See Also
  char(), charindex(), endswith(), extract(), group_concat(), 
  group_spooky_hash(), gunzip(), gzip(), humanize_file_size(), instr(), 
  leftstr(), length(), logfmt2json(), lower(), ltrim(), padc(), padl(), 
  padr(), printf(), proper(), regexp_capture(), regexp_match(), 
  regexp_replace(), replace(), replicate(), reverse(), rightstr(), 
  rtrim(), sparkline(), spooky_hash(), startswith(), strfilter(), 
  substr(), trim(), unicode(), upper()
Examples
#1 To select the XML nodes on the path '/abc/def':
   ;SELECT * FROM xpath('/abc/def', '<abc><def a="b">Hello</def><def>Bye</def></abc>')
   

#2 To select all 'a' attributes on the path '/abc/def':
   ;SELECT * FROM xpath('/abc/def/@a', '<abc><def a="b">Hello</def><def>Bye</def></abc>')
   

#3 To select the text nodes on the path '/abc/def':
   ;SELECT * FROM xpath('/abc/def/text()', '<abc><def a="b">Hello &#x2605;</def></abc>')
   


zeroblob(N)
══════════════════════════════════════════════════════════════════════
  Returns a BLOB consisting of N bytes of 0x00.
Parameter
  N   The size of the BLOB.


ATTACH DATABASE filename AS schema-name
══════════════════════════════════════════════════════════════════════
  Attach a database file to the current connection.
Parameters
  filename      The path to the database file.
  schema-name   The prefix for tables in this database.

Example
#1 To attach the database file '/tmp/customers.db' with the name customers:
   ;ATTACH DATABASE '/tmp/customers.db' AS customers  
   


CASE [base-expr] WHEN cmp-expr1 THEN then-expr1 [... WHEN cmp-exprN THEN then-exprN] [ELSE else-expr] END
══════════════════════════════════════════════════════════════════════
  Evaluate a series of expressions in order until one evaluates to
  true and then return it's result.  Similar to an IF-THEN-ELSE
  construct in other languages.
Parameters
  base-expr   The base expression that is used for
              comparison in the branches
  cmp-expr    The expression to test if this branch should
              be taken
  else-expr   The result of this CASE if no branches
              matched.

Example
#1 To evaluate the number one and return the string 'one':
   ;SELECT CASE 1 WHEN 0 THEN 'zero' WHEN 1 THEN 'one' END
   


CREATE [TEMP] VIEW [IF NOT EXISTS] [schema-name.] view-name AS select-stmt
══════════════════════════════════════════════════════════════════════
  Assign a name to a SELECT statement
Parameters
  IF NOT EXISTS   Do not create the view if it already
                  exists
  schema-name.    The database to create the view in
  view-name       The name of the view
  select-stmt     The SELECT statement the view
                  represents


DELETE FROM table-name [WHERE cond]
══════════════════════════════════════════════════════════════════════
  Delete rows from a table
Parameters
  table-name   The name of the table
  cond         The conditions used to delete the rows.


DETACH DATABASE schema-name
══════════════════════════════════════════════════════════════════════
  Detach a database from the current connection.
Parameter
  schema-name   The prefix for tables in this database.

Example
#1 To detach the database named 'customers':
   ;DETACH DATABASE customers                         
   


DROP VIEW [IF EXISTS] [schema-name.] view-name
══════════════════════════════════════════════════════════════════════
  Drop a view
Parameters


INSERT INTO [schema-name.] table-name [( column-name1 [, ... column-nameN] )] VALUES ( expr1 [, ... exprN] )
══════════════════════════════════════════════════════════════════════
  Insert rows into a table
Parameters

Example
#1 To insert the pair containing 'MSG' and 'HELLO, WORLD!' into the
   'environ' table:
   ;INSERT INTO environ VALUES ('MSG', 'HELLO, WORLD!')
   


OVER window-name
══════════════════════════════════════════════════════════════════════
  Executes the preceding function over a window
Parameter
  window-name   The name of the window definition


SELECT result-column1 [, ... result-columnN] [FROM table1 [, ... tableN]] [WHERE cond] [GROUP BY grouping-expr1 [, ... grouping-exprN]] [ORDER BY ordering-term1 [, ... ordering-termN]] [LIMIT limit-expr1 [, ... limit-exprN]]
══════════════════════════════════════════════════════════════════════
  Query the database and return zero or more rows of data.
Parameters
  result-column   The expression used to generate a
                  result for this column.
  table           The table(s) to query for data
  cond            The conditions used to select the
                  rows to return.
  grouping-expr   The expression to use when grouping
                  rows.
  ordering-term   The values to use when ordering the
                  result set.
  limit-expr      The maximum number of rows to
                  return.

Example
#1 To select all of the columns from the table 'syslog_log':
   ;SELECT * FROM syslog_log                          
   


UPDATE table SET column-name1 = expr1 [, ... column-nameN = exprN] [WHERE cond]
══════════════════════════════════════════════════════════════════════
  Modify a subset of values in zero or more rows of the given table
Parameters
  table         The table to update
  column-name   The columns in the table to update.
  cond          The condition used to determine whether
                a row should be updated.

Example
#1 To mark the syslog message at line 40:
   ;UPDATE syslog_log SET log_mark = 1 WHERE log_line = 40
   


WITH [RECURSIVE] cte-table-name AS select-stmt
══════════════════════════════════════════════════════════════════════
  Create a temporary view that exists only for the duration of a SQL
  statement.
Parameters
  cte-table-name   The name for the temporary table.
  select-stmt      The SELECT statement used to
                   populate the temporary table.