- Reference manual
- The SWI-Prolog library
- library(aggregate): Aggregation operators on backtrackable predicates
- library(apply): Apply predicates on a list
- library(assoc): Association lists
- library(broadcast): Broadcast and receive event notifications
- library(charsio): I/O on Lists of Character Codes
- library(check): Consistency checking
- library(clpb): CLP(B): Constraint Logic Programming over Boolean Variables
- library(clpfd): CLP(FD): Constraint Logic Programming over Finite Domains
- library(clpqr): Constraint Logic Programming over Rationals and Reals
- library(csv): Process CSV (Comma-Separated Values) data
- library(debug): Print debug messages and test assertions
- library(error): Error generating support
- library(gensym): Generate unique identifiers
- library(iostream): Utilities to deal with streams
- library(lists): List Manipulation
- library(main): Provide entry point for scripts
- library(nb_set): Non-backtrackable set
- library(www_browser): Activating your Web-browser
- library(option): Option list processing
- library(optparse): command line parsing
- library(ordsets): Ordered set manipulation
- library(pairs): Operations on key-value lists
- library(persistency): Provide persistent dynamic predicates
- library(pio): Pure I/O
- library(predicate_options): Declare option-processing of predicates
- library(prolog_pack): A package manager for Prolog
- library(prolog_xref): Cross-reference data collection library
- library(quasi_quotations): Define Quasi Quotation syntax
- library(random): Random numbers
- library(readutil): Reading lines, streams and files
- library(record): Access named fields in a term
- library(registry): Manipulating the Windows registry
- library(simplex): Solve linear programming problems
- library(solution_sequences): Modify solution sequences
- library(tabling): Tabled execution (SLG)
- library(thread_pool): Resource bounded thread management
- library(ugraphs): Unweighted Graphs
- library(url): Analysing and constructing URL
- library(varnumbers): Utilities for numbered terms
- library(yall): Lambda expressions
- The SWI-Prolog library
- Reference manual
- See also
- RFC 4180
- To be done
- - Implement immediate assert of the data to avoid possible stack
- Writing creates an intermediate code-list, possibly overflowing resources. This waits for pure output!
This library parses and generates CSV data. CSV data is represented in Prolog as a list of rows. Each row is a compound term, where all rows have the same name and arity.
- [det]csv_read_file(+File, -Rows)
- [det]csv_read_file(+File, -Rows, +Options)
- Read a CSV file into a list of rows. Each row is a Prolog term with the
same arity. Options is handed to csv//2.
Remaining options are processed by phrase_from_file/3.
The default separator depends on the file name extension and is
Suppose we want to create a predicate table/6 from a CSV file that we know contains 6 fields per record. This can be done using the code below. Without the option
arity(6), this would generate a predicate table/N, where N is the number of fields per record in the data.
?- csv_read_file(File, Rows, [functor(table), arity(6)]), maplist(assert, Rows).
- Prolog DCG to `read/write' CSV data. Options:
- The comma-separator. Must be a character code. Default is (of course)
the comma. Character codes can be specified using the 0' notion. E.g.,
separator(0';)parses a semicolon separated file.
true(default false), threat double quotes as a normal character.
false), strip leading and trailing blank space. RFC4180 says that blank space is part of the data.
true(default), use name/2 on the field data. This translates the field into a number if possible.
down, downcase atomic values. If
up, upcase them and if
preserve(default), do not change the case.
- Functor to use for creating row terms. Default is
- Number of fields in each row. This predicate raises a
domain_error(row_arity(Expected), Found)if a row is found with different arity.
true), do not reject CSV files where lines provide a varying number of fields (columns). This can be a work-around to use some incorrect CSV files.
- [nondet]csv_read_file_row(+File, -Row, +Options)
- True when Row is a row in File. First unifies Row
with the first row in File. Backtracking yields the second,
... row. This interface is an alternative to csv_read_file/3
that avoids loading all rows in memory. Note that this interface does
not guarantee that all rows in File have the same arity.
In addition to the options of csv_read_file/3, this predicate processes the option:
- Line is unified with the 1-based line-number from which Row is read. Note that Line is not the physical line, but rather the logical record number.
- To be done
- Input is read line by line. If a record separator is embedded in a quoted field, parsing the record fails and another line is added to the input. This does not nicely deal with other reasons why parsing the row may fail.
- [det]csv_read_row(+Stream, -Row, +CompiledOptions)
- Read the next CSV record from Stream and unify the result
CompiledOptions is created from options defined for csv//2
is unified with
end_of_fileupon reaching the end of the input.
- [det]csv_options(-Compiled, +Options)
- Compiled is the compiled representation of the CSV processing options as they may be passed into csv//2, etc. This predicate is used in combination with csv_read_row/3 to avoid repeated processing of the options.
- [det]csv_write_file(+File, +Data)
- [det]csv_write_file(+File, +Data, +Options)
- Write a list of Prolog terms to a CSV file. Options are given
to csv//2. Remaining options
are given to open/4. The
default separator depends on the file name extension and is
- [det]csv_write_stream(+Stream, +Data, +Options)
- Write the rows in Data to Stream. This is similar
but can deal with data that is produced incrementally. The example below
saves all answers from the predicate data/3
save_data(File) :- setup_call_cleanup( open(File, write, Out), forall(data(C1,C2,C3), csv_write_stream(Out, [row(C1,C2,C3)], )), close(Out)),