Table creation: Difference between revisions
Added BASIC256
SqrtNegInf (talk | contribs) m (→{{header|Raku}}: Fix comments: Perl 6 --> Raku) |
(Added BASIC256) |
||
(11 intermediate revisions by 8 users not shown) | |||
Line 8:
* [[Table Creation - Address]]
<br><br>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">; Helper functions
createTable: function [][
query db {!sql DROP TABLE IF EXISTS users}
query db {!sql
CREATE TABLE users (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT NOT NULL,
email TEXT NOT NULL,
age INTEGER
)
}
]
addUser: function [name, email, age][
query.id db ~{!sql
INSERT INTO users (username, email, age)
VALUES ('|name|','|email|','|age|')
}
]
findUser: function [name][
query db ~{!sql
SELECT *
FROM users
WHERE username='|name|'
}
]
db: open.sqlite "users.db"
createTable
print ["added user with id:" addUser "JohnDoe" "jodoe@gmail.com" 35]
print ["added user with id:" addUser "JaneDoe" "jadoe@gmail.com" 14]
print ["getting user with name: JohnDoe =>" findUser "JohnDoe"]
close db</syntaxhighlight>
{{out}}
<pre>added user with id: 1
added user with id: 2
getting user with name: JohnDoe => [[1 JohnDoe jodoe@gmail.com 35]] </pre>
=={{header|AWK}}==
Line 14 ⟶ 62:
AWK is just a glue language. Simply pipe the creation command into SQLite and capture the output.
<
awk '
BEGIN {
Line 21 ⟶ 69:
exit;
}
'</
=={{header|BASIC256}}==
<syntaxhighlight lang="vbnet"># create a new database file or open it
dbopen "mydbtest.sqlite3"
# delete the existing table in Personas - If it is a new database, the error is captured
onerror errortrap
dbexecute "drop table Personas;"
offerror
# create the table and enter data into it
dbexecute "create table Personas (id integer, nombre text, apellido text, edad integer, direccion string(50), salario decimal);"
dbexecute "insert into Personas values (1, 'Juan', 'Hdez', 52, '123 Calle Principal', 50000.00);"
# open a recordset and loop through the rows of data
print "Contents of the Personas table:"
dbopenset "select * from Personas order by nombre;"
while dbrow()
print dbint(0) + " " + dbstring(1) + " " + dbstring(2) + " " + dbint(3) + " " + dbstring(4) + " " + dbfloat(5)
end while
dbcloseset
# close all
dbclose
end
errortrap:
# accept the error - show nothing - return to the next statement
return</syntaxhighlight>
{{out}}
<pre>Contents of the Personas table:
1 Juan Hdez 52 123 Calle Principal 50000.0</pre>
=={{header|C}}==
Line 27 ⟶ 108:
{{libheader|SQLite}}
<syntaxhighlight lang="c">
#include <sqlite3.h>
#include <stdlib.h>
Line 55 ⟶ 136:
return 0;
}
</syntaxhighlight>
=={{header|FunL}}==
<
import util.*
Line 84 ⟶ 165:
statement.execute( "SELECT * FROM Persons ORDER BY LastName" )
print( TextTable.apply(statement.getResultSet()) )
conn.close()</
{{out}}
Line 99 ⟶ 180:
+----------+-----------+----------+------------------------------+-------------+----------+
</pre>
=={{header|FreeBASIC}}==
{{libheader|SQLite}}
<syntaxhighlight lang="vbnet">#include once "sqlite3.bi"
Const NULL As Any Ptr = 0
Dim As sqlite3 Ptr db
Dim As zstring Ptr errMsg
Dim As sqlite3_stmt Ptr stmt
If sqlite3_open(":memory:", @db) <> SQLITE_OK Then
Print "Could not open database: "; sqlite3_errmsg(db)
sqlite3_close(db)
Sleep
End 1
End If
' Create the table
Dim As String sql = "CREATE TABLE Persons(" _
& "ID INT PRIMARY KEY NOT NULL," _
& "NAME TEXT NOT NULL," _
& "SURNAME TEXT NOT NULL," _
& "AGE INT NOT NULL," _
& "ADDRESS CHAR(50)," _
& "SALARY REAL );"
If sqlite3_exec(db, sql, NULL, NULL, @errMsg) <> SQLITE_OK Then
Print "Error creating table: "; *errMsg
sqlite3_free(errMsg)
Else
Print "Table created successfully"
End If
' Insert some data
sql = "INSERT INTO Persons (ID, NAME, SURNAME, AGE, ADDRESS, SALARY) " _
& "VALUES (1, 'John', 'Doe', 30, '123 Main St', 50000.00);"
If sqlite3_exec(db, sql, NULL, NULL, @errMsg) <> SQLITE_OK Then
Print "Error inserting data: "; *errMsg
sqlite3_free(errMsg)
End If
' Display the contents of the table
sql = "SELECT * FROM Persons;"
If sqlite3_prepare_v2(db, sql, -1, @stmt, NULL) <> SQLITE_OK Then
Print "Error preparing statement: "; sqlite3_errmsg(db)
Else
While sqlite3_step(stmt) = SQLITE_ROW
Print "ID: "; sqlite3_column_int(stmt, 0)
Print "Name: "; *cast(zstring ptr, sqlite3_column_text(stmt, 1))
Print "Surname: "; *cast(zstring ptr, sqlite3_column_text(stmt, 2))
Print "Age: "; sqlite3_column_int(stmt, 3)
Print "Address: "; *cast(zstring ptr, sqlite3_column_text(stmt, 4))
Print "Salary: "; sqlite3_column_double(stmt, 5)
Print
Wend
End If
sqlite3_finalize(stmt)
sqlite3_close(db)
Sleep</syntaxhighlight>
{{out}}
<pre>Table created successfully
ID: 1
Name: Juan
Surname: Hdez
Age: 52
Address: 123 Main St
Salary: 50000</pre>
=={{header|Go}}==
Line 104 ⟶ 257:
<br>
This uses a key/value store rather than a relational database to create the table.
<
import (
Line 193 ⟶ 346:
return nil
})
}</
{{out}}
Line 209 ⟶ 362:
If we define a <code>table</code> as a named collection of columns, and we define a <code>type</code> as a mechanism for the representation of some kind of data, then:
<
insertStock=: 3 :'0#stocks=: stocks,.y'
insertStock@".;._2]0 :0
Line 216 ⟶ 369:
'2006-04-05'; 'BUY'; 'MSOFT'; 1000; 72.00
'2006-04-06'; 'SELL'; 'IBM'; 500; 53.00
)</
declares a table and some data within that table.
Line 222 ⟶ 375:
And, here's an example of sorting:
<
sortBy=: [ /:"1 2 (<__)|:@,. [ }.@{~ cols
from=: cols~ {"0 _ ]
Line 238 ⟶ 391:
├──────────┼─────┼──────┼────┼─────┤
│2006-04-05│BUY │MSOFT │1000│72 │
└──────────┴─────┴──────┴────┴─────┘</
Note that this particular example is both overly general in some senses (for example, named column handling has features not demonstrated here) and overly specific in others (for example, I did not implement sort in descending order).
Line 247 ⟶ 400:
{{works with|Julia|0.6}}
<
conn = SQLite.DB() # in-memory
Line 269 ⟶ 422:
df = SQLite.query(conn, "select * from stocks order by price")
println(df)</
{{out}}
Line 281 ⟶ 434:
=={{header|Lua}}==
<
Columns.ID = {};
Columns.FName = {};
Line 336 ⟶ 489:
--[[ ]]--
listTables();</
{{out}}
Line 355 ⟶ 508:
We can use text from UTF16LE set. Here we have Greek letters in Memo.
<syntaxhighlight lang="m2000 interpreter">
MODULE SIMPLEBASE {
BASE "ALFA" ' ERASED IF FOUND THE NAME OF "ALFA.MDB"
Line 371 ⟶ 524:
}
SIMPLEBASE
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
"databases:1234/conn_test"], "Username" -> "test"]
SQLCreateTable[conn, SQLTable["TEST"],If[Length[#] == 0,SQLColumn[StringJoin[#,"COL"],"DataTypeName" -> #],SQLColumn[StringJoin[#[[1]], "COL"], "DataTypeName" -> #[[1]],"DataLength" -> #[[2]]]] & /@ {"TINYINT", "SMALLINT", "INTEGER","BIGINT", "NUMERIC", "DECIMAL", "FLOAT", "REAL", "DOUBLE", "BIT","LONGVARBINARY", "VARBINARY", "BINARY","LONGVARCHAR",{"VARCHAR", 5},{"CHAR", 3},"DATE","TIME","TIMESTAMP","OBJECT"}]</
=={{header|Nim}}==
{{trans|Python}}
Nim standard library provides two modules to work with SQL databases. We use here the high level one for SQLite.
<syntaxhighlight lang="nim">import db_sqlite
let dbc = open(":memory:", "", "", "")
dbc.exec(sql"create table stocks(date text, trans text, symbol text, qty real, price real)")
# Insert a row of data.
dbc.exec(sql"insert into stocks values ('2006-01-05', 'BUY', 'RHAT', 100, 35.14)")
for v in [("2006-03-28", "BUY", "IBM", 1000, 45.00),
("2006-04-05", "BUY", "MSOFT", 1000, 72.00),
("2006-04-06", "SELL", "IBM", 500, 53.00)]:
dbc.exec(sql"insert into stocks values (?, ?, ?, ?, ?)", v[0], v[1], v[2], v[3], v[4])
# Data retrieval.
for row in dbc.fastRows(sql"select * from stocks order by price"):
echo row</syntaxhighlight>
{{out}}
<pre>@["2006-01-05", "BUY", "RHAT", "100.0", "35.14"]
@["2006-03-28", "BUY", "IBM", "1000.0", "45.0"]
@["2006-04-06", "SELL", "IBM", "500.0", "53.0"]
@["2006-04-05", "BUY", "MSOFT", "1000.0", "72.0"]</pre>
=={{header|Oracle}}==
Great SCOTT! from utlsampl.sql
<
CREATE TABLE EMP
(EMPNO NUMBER(4) CONSTRAINT PK_EMP PRIMARY KEY,
Line 390 ⟶ 570:
COMM NUMBER(7,2),
DEPTNO NUMBER(2) CONSTRAINT FK_DEPTNO REFERENCES DEPT);
</syntaxhighlight>
=={{header|Oz}}==
Line 398 ⟶ 578:
{{libheader|Ozsqlite}}
<
[Sqlite] = {Module.link ['x-ozlib:/sqlite/Sqlite.ozf']}
Line 435 ⟶ 615:
{Sqlite.close DB}
end
</syntaxhighlight>
=={{header|PARI/GP}}==
The most natural way to store tabular data in GP is in a matrix:
<
m[1,] = ["Barack", "Obama", 20500];
\\ ...</
=={{header|Perl}}==
{{trans|Julia}}
<syntaxhighlight lang="perl"># 20211218 Perl programming solution
use strict;
use warnings;
use DBI;
my $dbh = DBI->connect("dbi:SQLite:dbname=:memory:");
$dbh->do("CREATE TABLE stocks (
date TEXT, trans TEXT, symbol TEXT, qty REAL, price REAL
)");
my $sth = $dbh->prepare( "INSERT INTO stocks VALUES (?,?,?,?,?)" );
my @DATA = ( '"2006-01-05","BUY", "RHAT", 100, 35.14',
'"2006-03-28","BUY", "IBM", 1000, 45.00',
'"2006-04-05","BUY","MSOFT", 1000, 72.00',
'"2006-04-06","SELL", "IBM", 500, 53.00' );
for ( @DATA ) { $sth->execute( split /,/ ) or die }
$sth = $dbh->prepare("SELECT * FROM stocks ORDER BY price") or die;
$sth->execute();
my $format = "%-15s %-15s %-15s %-15s %-15s\n";
printf $format, $sth->{NAME}->@* ;
print '=' x 75 , "\n";
while ( my @row = $sth->fetchrow_array ) { printf $format, @row }</syntaxhighlight>
{{out}}
<pre>
date trans symbol qty price
===========================================================================
"2006-01-05" "BUY" "RHAT" 100 35.14
"2006-03-28" "BUY" "IBM" 1000 45
"2006-04-06" "SELL" "IBM" 500 53
"2006-04-05" "BUY" "MSOFT" 1000 72
</pre>
=={{header|Phix}}==
{{libheader|SQLite}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">include</span> <span style="color: #000000;">pSQLite</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">sqlcode</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
CREATE TABLE IF NOT EXISTS employee (
empID INTEGER PRIMARY KEY AUTOINCREMENT,
dob DATE NOT NULL)"""</span>
<span style="color: #000000;">sqlite3</span> <span style="color: #000000;">db</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sqlite3_open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"employees.sqlite"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sqlite3_exec</span><span style="color: #0000FF;">(</span><span style="color: #000000;">db</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sqlcode</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">=</span><span style="color: #000000;">SQLITE_OK</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">sqlite3_close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">db</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"sqlite3_exec error: %d [%s]\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sqlite_last_exec_err</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
<
(class +Account +Entity)
Line 497 ⟶ 724:
(if (: active) "Yes" "No")
(: username)
(money (: balance)) ) ) )</
Output:
<pre>account_id created active username balance
Line 504 ⟶ 731:
=={{header|PL/I}}==
<
2 name character (20) varying,
2 address,
Line 513 ⟶ 740:
2 transaction_date date,
2 sex character (1),
2 suppress_junk_mail bit (1);</
=={{header|PostgreSQL}}==
Line 519 ⟶ 746:
Postgres developers, please feel free to add additional data-types you commonly use to this example.
<
CREATE SEQUENCE account_seq start 100;
Line 546 ⟶ 773:
-- char(#): space padded text field with length of #
-- varchar(#): variable length text field up to #
-- text: not limited</
=={{header|Python}}==
{{libheader|SQLite}}
The sqlite3 database is a part of the Python standard library. It does not associate type with table columns, any cell can be of any type.
<
>>> conn = sqlite3.connect(':memory:')
>>> c = conn.cursor()
Line 585 ⟶ 812:
(u'2006-04-06', u'SELL', u'IBM', 500.0, 53.0)
(u'2006-04-05', u'BUY', u'MSOFT', 1000.0, 72.0)
>>> </
=={{header|Racket}}==
This is the relevant part of [[Table creation/Postal addresses#Racket]] that creates the DB table:
<
#lang racket
(require db)
(define postal (sqlite3-connect #:database "/tmp/postal.db" #:mode 'create))
</syntaxhighlight>
=={{header|Raku}}==
Line 624 ⟶ 851:
</pre>
If you want a persistent instance of any of these types, you need to declare the name with some scope constraint, but
=={{header|REXX}}==
Line 631 ⟶ 858:
However, tables (or structures) can be constructed by using stemmed arrays; the index would (should) be
<br>a unique identifier, something akin to a SSN (Social Security Number) or something similar.
<
table.id.!firstname = 'Robert'
Line 642 ⟶ 869:
table.id.!town = 'Gotham City'
table.id.!state = 'NY'
table.id.!zip = '12345-6789'</
=={{header|Ring}}==
<
# Project : Table creation
Line 684 ⟶ 911:
next
sqlite_close(oSQLite)
</syntaxhighlight>
Output:
<pre>
Line 717 ⟶ 944:
This code is enough to create a PStore (or open an existing PStore).
<
db = PStore.new "filename.pstore"</
The example at [[Table creation/Postal addresses#Ruby]] puts Ruby objects into the PStore.
Line 725 ⟶ 952:
Run Basic supports all features of SQLite.
This is a sample of a item master
<
#sql execute("
CREATE TABLE item (
Line 764 ⟶ 991:
CREATE UNIQUE INDEX item_descr ON item( descr, itemNum);
CREATE UNIQUE INDEX item_itemNum ON item(itemNum);"
</syntaxhighlight>
=={{header|Scala}}==
===using SLICK FRM===
<
import slick.jdbc.H2Profile.api._
Line 803 ⟶ 1,030:
// Create the tables, including primary and foreign keys
(suppliers.schema ++ coffees.schema).create
)}</
=={{header|SQL PL}}==
{{works with|Db2 LUW}}
<
CREATE TABLE dept (
deptno NUMERIC(2)
Line 841 ⟶ 1,068:
INSERT INTO emp VALUES (7902, 'FORD', 'ANALYST', 7566, '1981-12-03', 3000, NULL, 20);
INSERT INTO emp VALUES (7934, 'MILLER', 'CLERK', 7782, '1982-01-23', 1300, NULL, 10);
</syntaxhighlight>
Output:
<pre>
Line 941 ⟶ 1,168:
=={{header|Tcl}}==
Tables, as used in relational databases, seem far away conceptually from Tcl. However, the following code demonstrates how a table (implemented as a list of lists, the first being the header line) can be type-checked and rendered:
<
upvar $_tbl tbl
set heads [lindex $tbl 0]
Line 1,015 ⟶ 1,242:
balance 0.0 \
created 2009-05-14
puts [table_format $mytbl]</
Output:
<pre>
Line 1,024 ⟶ 1,251:
| 12346 | 2009-05-14 | | Jane Miller | 0.0 |
+------------+------------+--------+-------------+---------+
</pre>
=={{header|Wren}}==
===Version 1===
{{libheader|Wren-dynamic}}
{{libheader|Wren-fmt}}
{{libheader|Wren-sort}}
Wren-cli does not currently have access to any external databases so, for the purposes of this task, we devise our own very simple in-memory database format, create a table, add some records to it and display them.
In practice, a binary search would be needed to find records quickly by key given that the records are being maintained in sorted order. However, for now we use a sequential search instead.
<syntaxhighlight lang="wren">import "./dynamic" for Enum, Tuple
import "./fmt" for Fmt
import "./sort" for Cmp, Sort
var FieldType = Enum.create("FieldType", ["text", "num", "int", "bool"])
var Field = Tuple.create("Field", ["name", "fieldType", "maxLen"])
class Table {
construct new(name, fields, keyIndex) {
_name = name
_fields = fields
_keyIndex = keyIndex // the zero based index of the field to sort on
_records = []
_fmt = ""
for (f in _fields) {
var c = f.name.count
var l = f.maxLen.max(c)
if (f.fieldType == FieldType.text ||f.fieldType == FieldType.bool) {
l = -l
}
_fmt = _fmt + "$%(l)s "
}
_fmt = _fmt.trimEnd()
}
name { _name }
showFields() {
System.print("Fields for %(_name) table:\n")
Fmt.print("$-20s $4s $s", "name", "type", "maxlen")
System.print("-" * 33)
for (f in _fields) {
Fmt.print("$-20s $-4s $d", f.name, FieldType.members[f.fieldType], f.maxLen)
}
}
cmp_ { Fn.new { |r1, r2|
return (Num.fromString(r1[_keyIndex]) - Num.fromString(r2[_keyIndex])).sign
}}
addRecord(record) {
var items = record.split(", ")
_records.add(items)
Sort.insertion(_records, cmp_) // move new record into sorted order
}
showRecords() {
System.print("Records for %(_name) table:\n")
var h = Fmt.slwrite(_fmt, _fields.map { |f| f.name }.toList)
System.print(h)
System.print("-" * h.count)
for (r in _records) {
Fmt.lprint(_fmt, r)
}
}
removeRecord(key) {
for (i in 0..._records.count) {
if (_records[i][_keyIndex] == key.toString) {
_records.removeAt(i)
return
}
}
}
findRecord(key) {
for (i in 0..._records.count) {
if (_records[i][_keyIndex] == key.toString) {
return _records[i].join(", ")
}
}
return null
}
}
var fields = []
fields.add(Field.new("id", FieldType.int, 2))
fields.add(Field.new("date", FieldType.text, 10))
fields.add(Field.new("trans", FieldType.text, 4))
fields.add(Field.new("sym", FieldType.text, 5))
fields.add(Field.new("qty", FieldType.int, 4))
fields.add(Field.new("price", FieldType.num, 5))
fields.add(Field.new("settled", FieldType.bool, 5))
// create table
var table = Table.new("Stock_transactions", fields, 0)
// add records in unsorted order
table.addRecord("3, 2006-04-06, SELL, IBM, 500, 53.00, true")
table.addRecord("1, 2006-01-05, BUY, RHAT, 100, 35.14, true")
table.addRecord("4, 2006-04-05, BUY, MSOFT, 1000, 72.00, false")
table.addRecord("2, 2006-03-28, BUY, IBM, 1000, 45.00, true")
// show the table's fields
table.showFields()
System.print()
// show the table's records in sorted order
table.showRecords()
// find a record by key
System.print("\nThe record with an id of 2 is:")
System.print(table.findRecord(2))
// delete a record by key
table.removeRecord(3)
System.print("\nThe record with an id of 3 will be deleted, leaving:\n")
table.showRecords()</syntaxhighlight>
{{out}}
<pre>
Fields for Stock_transactions table:
name type maxlen
---------------------------------
id int 2
date text 10
trans text 4
sym text 5
qty int 4
price num 5
settled bool 5
Records for Stock_transactions table:
id date trans sym qty price settled
--------------------------------------------------
1 2006-01-05 BUY RHAT 100 35.14 true
2 2006-03-28 BUY IBM 1000 45.00 true
3 2006-04-06 SELL IBM 500 53.00 true
4 2006-04-05 BUY MSOFT 1000 72.00 false
The record with an id of 2 is:
2, 2006-03-28, BUY, IBM, 1000, 45.00, true
The record with an id of 3 will be deleted, leaving:
Records for Stock_transactions table:
id date trans sym qty price settled
--------------------------------------------------
1 2006-01-05 BUY RHAT 100 35.14 true
2 2006-03-28 BUY IBM 1000 45.00 true
4 2006-04-05 BUY MSOFT 1000 72.00 false
</pre>
<br>
===Version 2===
{{libheader|Wren-table}}
The above module provides a more generic way to create simple databases and was not available when the first version was written.
<syntaxhighlight lang="wren">import "./table" for FieldInfo, Table, Records
var fields = [
FieldInfo.new("id", Num),
FieldInfo.new("date", String),
FieldInfo.new("trans", String),
FieldInfo.new("sym", String),
FieldInfo.new("qty", Num),
FieldInfo.new("price", Num),
FieldInfo.new("settled", Bool)
]
// create table
var table = Table.new("Stock_transactions", fields)
// add records
table.add([3, "2006-04-06", "SELL", "IBM" , 500, 53.00, true ])
table.add([1, "2006-01-05", "BUY" , "RHAT" , 100, 35.14, true ])
table.add([4, "2006-04-05", "BUY" , "MSOFT", 1000, 72.00, false])
table.add([2, "2006-03-28", "BUY" , "IBM" , 1000, 45.00, true ])
var colWidths = [2, 10, 4, 5, 4, 5.2, 7] // for listings
// show the table's fields
table.listFields()
System.print()
// sort the records by 'id' and show them
var sortFn = Fn.new { |s, t| s[0] < t[0] }
var records = table.sortedRecords(sortFn)
Records.list(table.fields, records, "Records for %(table.name) table:\n", colWidths)
// find a record by key
System.print("\nThe record with an id of 2 is:")
System.print(table.find(2))
// delete a record by key
table.remove(3)
System.print("\nThe record with an id of 3 will be deleted, leaving:\n")
records = table.sortedRecords(sortFn)
Records.list(table.fields, records, "Records for %(table.name) table:\n", colWidths)</syntaxhighlight>
{{out}}
<pre>
Fields for Stock_transactions table:
name kind
------- ------
id Num
date String
trans String
sym String
qty Num
price Num
settled Bool
Records for Stock_transactions table:
id date tran sym qty price settled
-- ---------- ---- ----- ---- ----- -------
1 2006-01-05 BUY RHAT 100 35.14 true
2 2006-03-28 BUY IBM 1000 45.00 true
3 2006-04-06 SELL IBM 500 53.00 true
4 2006-04-05 BUY MSOFT 1000 72.00 false
The record with an id of 2 is:
[2, 2006-03-28, BUY, IBM, 1000, 45, true]
The record with an id of 3 will be deleted, leaving:
Records for Stock_transactions table:
id date tran sym qty price settled
-- ---------- ---- ----- ---- ----- -------
1 2006-01-05 BUY RHAT 100 35.14 true
2 2006-03-28 BUY IBM 1000 45.00 true
4 2006-04-05 BUY MSOFT 1000 72.00 false
</pre>
|