fat_table 0.2.6 → 0.2.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.gitignore +1 -0
- data/.travis.yml +2 -0
- data/README.md +2168 -0
- data/README.org +230 -212
- data/TODO.org +7 -0
- data/bin/ft_console +82 -79
- data/fat_table.gemspec +45 -43
- data/lib/fat_table.rb +1 -1
- data/lib/fat_table/column.rb +31 -22
- data/lib/fat_table/db_handle.rb +61 -50
- data/lib/fat_table/evaluator.rb +20 -22
- data/lib/fat_table/formatters/aoa_formatter.rb +1 -2
- data/lib/fat_table/formatters/aoh_formatter.rb +1 -2
- data/lib/fat_table/formatters/formatter.rb +38 -33
- data/lib/fat_table/formatters/latex_formatter.rb +2 -2
- data/lib/fat_table/formatters/org_formatter.rb +5 -6
- data/lib/fat_table/formatters/term_formatter.rb +3 -5
- data/lib/fat_table/formatters/text_formatter.rb +3 -4
- data/lib/fat_table/patches.rb +29 -1
- data/lib/fat_table/table.rb +81 -77
- data/lib/fat_table/version.rb +1 -1
- metadata +80 -82
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 4c545f67e0496d870adfa57ec7bdbe6b8b0b5af8
|
|
4
|
+
data.tar.gz: 59a03a6b61876344facf14a5ec6a65bf47300b33
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: ec213d073ddad80a8167b05e3a0fad399886c605a41160c41c428e2664f030f862c159bb077558521ce1bb32fd004527ec540fb8e3e51906d993712b9be0abeb
|
|
7
|
+
data.tar.gz: e160d5bacf83be72296029835f22412565e27649c097869f2653b86b8b23a65d0d541593349221fde1c5b6dc381785b0d192f3cd434269c6a2647362f433cfdc
|
data/.gitignore
CHANGED
data/.travis.yml
CHANGED
data/README.md
ADDED
|
@@ -0,0 +1,2168 @@
|
|
|
1
|
+
|
|
2
|
+
# Table of Contents
|
|
3
|
+
|
|
4
|
+
1. [Introduction](#org23d768e)
|
|
5
|
+
2. [Installation](#org8d90fdf)
|
|
6
|
+
1. [Prerequisites](#org26d2aee)
|
|
7
|
+
2. [Installing the gem](#orga19109b)
|
|
8
|
+
3. [Usage](#org0b5ecd8)
|
|
9
|
+
1. [Quick Start](#org199fc3a)
|
|
10
|
+
2. [A Word About the Examples](#org1e51988)
|
|
11
|
+
3. [Anatomy of a Table](#org7d48b5d)
|
|
12
|
+
1. [Columns](#org4a6c98f)
|
|
13
|
+
2. [Headers](#org37bbf47)
|
|
14
|
+
3. [Groups](#org1c03cc1)
|
|
15
|
+
4. [Constructing Tables](#orgbf0e735)
|
|
16
|
+
1. [Empty Tables](#org80c41f5)
|
|
17
|
+
2. [From CSV or Org Mode files or strings](#org681a599)
|
|
18
|
+
3. [From Arrays of Arrays](#org4f683cf)
|
|
19
|
+
4. [From Arrays of Hashes](#org7980800)
|
|
20
|
+
5. [From SQL queries](#orgdab2ec1)
|
|
21
|
+
6. [Marking Groups in Input](#orgeb97e36)
|
|
22
|
+
5. [Accessing Parts of Tables](#orgf9cb237)
|
|
23
|
+
1. [Rows](#org4453cea)
|
|
24
|
+
2. [Columns](#org8a6dd85)
|
|
25
|
+
3. [Cells](#orgcc87a8b)
|
|
26
|
+
4. [Other table attributes](#org4a41de4)
|
|
27
|
+
6. [Operations on Tables](#org731fd13)
|
|
28
|
+
1. [Example Input Table](#orga96ca08)
|
|
29
|
+
2. [Select](#orga0c49b3)
|
|
30
|
+
3. [Where](#orge185ad7)
|
|
31
|
+
4. [Order\_by](#org57f51d1)
|
|
32
|
+
5. [Group\_by](#org1ee0a85)
|
|
33
|
+
6. [Join](#org6432f26)
|
|
34
|
+
7. [Set Operations](#org7d2857d)
|
|
35
|
+
8. [Uniq (aka Distinct)](#org073a8b5)
|
|
36
|
+
9. [Remove groups with degroup!](#orgd147303)
|
|
37
|
+
7. [Formatting Tables](#org9f4d633)
|
|
38
|
+
1. [Available Formatters](#orgb7b2335)
|
|
39
|
+
2. [Table Locations](#org4db9ae4)
|
|
40
|
+
3. [Formatting Directives](#orgd2128a3)
|
|
41
|
+
4. [Footers Methods](#org947e8a4)
|
|
42
|
+
5. [Formatting Methods](#orgcef241a)
|
|
43
|
+
6. [The `format` and `format_for` methods](#org7b25866)
|
|
44
|
+
4. [Development](#org62e325b)
|
|
45
|
+
5. [Contributing](#orgf51a2c9)
|
|
46
|
+
|
|
47
|
+
<https://travis-ci.org/ddoherty03/fat_table.svg?branch=master>
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
<a id="org23d768e"></a>
|
|
51
|
+
|
|
52
|
+
# Introduction
|
|
53
|
+
|
|
54
|
+
`FatTable` is a gem that treats tables as a data type. It provides methods for
|
|
55
|
+
constructing tables from a variety of sources, building them row-by-row,
|
|
56
|
+
extracting rows, columns, and cells, and performing aggregate operations on
|
|
57
|
+
columns. It also provides as set of SQL-esque methods for manipulating table
|
|
58
|
+
objects: `select` for filtering by columns or for creating new columns, `where`
|
|
59
|
+
for filtering by rows, `order_by` for sorting rows, `distinct` for eliminating
|
|
60
|
+
duplicate rows, `group_by` for aggregating multiple rows into single rows and
|
|
61
|
+
applying column aggregate methods to ungrouped columns, a collection of `join`
|
|
62
|
+
methods for combining tables, and more.
|
|
63
|
+
|
|
64
|
+
Furthermore, `FatTable` provides methods for formatting tables and producing
|
|
65
|
+
output that targets various output media: text, ANSI terminals, ruby data
|
|
66
|
+
structures, LaTeX tables, Emacs org-mode tables, and more. The formatting
|
|
67
|
+
methods can specify cell formatting in a way that is uniform across all the
|
|
68
|
+
output methods and can also decorate the output with any number of footers,
|
|
69
|
+
including group footers. `FatTable` applies formatting directives to the extent
|
|
70
|
+
they makes sense for the output medium and treats other formatting directives as
|
|
71
|
+
no-ops.
|
|
72
|
+
|
|
73
|
+
`FatTable` can be used to perform operations on data that are naturally best
|
|
74
|
+
conceived of as tables, which in my experience is quite often. It can also serve
|
|
75
|
+
as a foundation for providing reporting functions where flexibility about the
|
|
76
|
+
output medium can be quite useful. Finally `FatTable` can be used within Emacs
|
|
77
|
+
`org-mode` files in code blocks targeting the Ruby language. Org mode tables are
|
|
78
|
+
presented to a ruby code block as an array of arrays, so `FatTable` can read
|
|
79
|
+
them in with its `.from_aoa` constructor. A `FatTable` table output as an array
|
|
80
|
+
of arrays with its `.to_aoa` output function will be rendered in an org-mode
|
|
81
|
+
buffer as an org-table, ready for processing by other code blocks.
|
|
82
|
+
|
|
83
|
+
|
|
84
|
+
<a id="org8d90fdf"></a>
|
|
85
|
+
|
|
86
|
+
# Installation
|
|
87
|
+
|
|
88
|
+
|
|
89
|
+
<a id="org26d2aee"></a>
|
|
90
|
+
|
|
91
|
+
## Prerequisites
|
|
92
|
+
|
|
93
|
+
The `fat_table` gem depends on several libraries being available for building,
|
|
94
|
+
mostly those concerned with accessing databases. On an ubuntu system, the
|
|
95
|
+
following packages should be installed before you install the `fat_table` gem:
|
|
96
|
+
|
|
97
|
+
- ruby-dev
|
|
98
|
+
- build-essential
|
|
99
|
+
- libsqlite3-dev
|
|
100
|
+
- libpq-dev
|
|
101
|
+
- libmysqlclient-dev
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
<a id="orga19109b"></a>
|
|
105
|
+
|
|
106
|
+
## Installing the gem
|
|
107
|
+
|
|
108
|
+
Add this line to your application’s Gemfile:
|
|
109
|
+
|
|
110
|
+
gem 'fat_table'
|
|
111
|
+
|
|
112
|
+
And then execute:
|
|
113
|
+
|
|
114
|
+
$ bundle
|
|
115
|
+
|
|
116
|
+
Or install it yourself as:
|
|
117
|
+
|
|
118
|
+
$ gem install fat_table
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
<a id="org0b5ecd8"></a>
|
|
122
|
+
|
|
123
|
+
# Usage
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
<a id="org199fc3a"></a>
|
|
127
|
+
|
|
128
|
+
## Quick Start
|
|
129
|
+
|
|
130
|
+
`FatTable` provides table objects as a data type that can be constructed and
|
|
131
|
+
operated on in a number of ways. Here’s a quick example to illustrate the use of
|
|
132
|
+
the main features of `FatTable`. See the detailed explanations further on down.
|
|
133
|
+
|
|
134
|
+
require 'fat_table'
|
|
135
|
+
|
|
136
|
+
data =
|
|
137
|
+
[['Date', 'Code', 'Raw', 'Shares', 'Price', 'Info', 'Ok'],
|
|
138
|
+
['2013-05-29', 'S', 15_700.00, 6601.85, 24.7790, 'ENTITY3', 'F'],
|
|
139
|
+
['2013-05-02', 'P', 118_186.40, 118_186.4, 11.8500, 'ENTITY1', 'T'],
|
|
140
|
+
['2013-05-20', 'S', 12_000.00, 5046.00, 28.2804, 'ENTITY3', 'F'],
|
|
141
|
+
['2013-05-23', 'S', 8000.00, 3364.00, 27.1083, 'ENTITY3', 'T'],
|
|
142
|
+
['2013-05-23', 'S', 39_906.00, 16_780.47, 25.1749, 'ENTITY3', 'T'],
|
|
143
|
+
['2013-05-20', 'S', 85_000.00, 35_742.50, 28.3224, 'ENTITY3', 'T'],
|
|
144
|
+
['2013-05-02', 'P', 795_546.20, 795_546.2, 1.1850, 'ENTITY1', 'T'],
|
|
145
|
+
['2013-05-29', 'S', 13_459.00, 5659.51, 24.7464, 'ENTITY3', 'T'],
|
|
146
|
+
['2013-05-20', 'S', 33_302.00, 14_003.49, 28.6383, 'ENTITY3', 'T'],
|
|
147
|
+
['2013-05-29', 'S', 15_900.00, 6685.95, 24.5802, 'ENTITY3', 'T'],
|
|
148
|
+
['2013-05-30', 'S', 6_679.00, 2808.52, 25.0471, 'ENTITY3', 'T'],
|
|
149
|
+
['2013-05-23', 'S', 23_054.00, 9694.21, 26.8015, 'ENTITY3', 'F']]
|
|
150
|
+
|
|
151
|
+
# Build the Table and then perform chained operations on it
|
|
152
|
+
|
|
153
|
+
table = FatTable.from_aoa(data) \
|
|
154
|
+
.where('shares > 2000') \
|
|
155
|
+
.order_by(:date, :code) \
|
|
156
|
+
.select(:date, :code, :shares,
|
|
157
|
+
:price, :ok, ref: '@row') \
|
|
158
|
+
.select(:ref, :date, :code,
|
|
159
|
+
:shares, :price, :ok)
|
|
160
|
+
|
|
161
|
+
# Convert the table to an ASCII text string
|
|
162
|
+
|
|
163
|
+
table.to_text do |fmt|
|
|
164
|
+
# Add some table footers
|
|
165
|
+
fmt.avg_footer(:price, :shares)
|
|
166
|
+
fmt.sum_footer(:shares)
|
|
167
|
+
# Add a group footer
|
|
168
|
+
fmt.gfooter('Avg', shares: :avg, price: :avg)
|
|
169
|
+
# Formats for all locations
|
|
170
|
+
fmt.format(ref: 'CB', numeric: 'R', boolean: 'CY')
|
|
171
|
+
# Formats for different "locations" in the table
|
|
172
|
+
fmt.format_for(:header, string: 'CB')
|
|
173
|
+
fmt.format_for(:body, code: 'C', shares: ',0.1', price: '0.4', )
|
|
174
|
+
fmt.format_for(:bfirst, price: '$0.4', )
|
|
175
|
+
fmt.format_for(:footer, shares: 'B,0.1', price: '$B0.4', )
|
|
176
|
+
fmt.format_for(:gfooter, shares: 'B,0.1', price: 'B0.4', )
|
|
177
|
+
end
|
|
178
|
+
|
|
179
|
+
+=========+============+======+=============+==========+====+
|
|
180
|
+
| Ref | Date | Code | Shares | Price | Ok |
|
|
181
|
+
+---------|------------|------|-------------|----------|----+
|
|
182
|
+
| 1 | 2013-05-02 | P | 118,186.4 | $11.8500 | Y |
|
|
183
|
+
| 2 | 2013-05-02 | P | 795,546.2 | 1.1850 | Y |
|
|
184
|
+
+---------|------------|------|-------------|----------|----+
|
|
185
|
+
| Avg | | | 456,866.3 | 6.5175 | |
|
|
186
|
+
+---------|------------|------|-------------|----------|----+
|
|
187
|
+
| 3 | 2013-05-20 | S | 5,046.0 | 28.2804 | N |
|
|
188
|
+
| 4 | 2013-05-20 | S | 35,742.5 | 28.3224 | Y |
|
|
189
|
+
| 5 | 2013-05-20 | S | 14,003.5 | 28.6383 | Y |
|
|
190
|
+
+---------|------------|------|-------------|----------|----+
|
|
191
|
+
| Avg | | | 18,264.0 | 28.4137 | |
|
|
192
|
+
+---------|------------|------|-------------|----------|----+
|
|
193
|
+
| 6 | 2013-05-23 | S | 3,364.0 | 27.1083 | Y |
|
|
194
|
+
| 7 | 2013-05-23 | S | 16,780.5 | 25.1749 | Y |
|
|
195
|
+
| 8 | 2013-05-23 | S | 9,694.2 | 26.8015 | N |
|
|
196
|
+
+---------|------------|------|-------------|----------|----+
|
|
197
|
+
| Avg | | | 9,946.2 | 26.3616 | |
|
|
198
|
+
+---------|------------|------|-------------|----------|----+
|
|
199
|
+
| 9 | 2013-05-29 | S | 6,601.9 | 24.7790 | N |
|
|
200
|
+
| 10 | 2013-05-29 | S | 5,659.5 | 24.7464 | Y |
|
|
201
|
+
| 11 | 2013-05-29 | S | 6,686.0 | 24.5802 | Y |
|
|
202
|
+
+---------|------------|------|-------------|----------|----+
|
|
203
|
+
| Avg | | | 6,315.8 | 24.7019 | |
|
|
204
|
+
+---------|------------|------|-------------|----------|----+
|
|
205
|
+
| 12 | 2013-05-30 | S | 2,808.5 | 25.0471 | Y |
|
|
206
|
+
+---------|------------|------|-------------|----------|----+
|
|
207
|
+
| Avg | | | 2,808.5 | 25.0471 | |
|
|
208
|
+
+---------|------------|------|-------------|----------|----+
|
|
209
|
+
| Average | | | 85,009.9 | $23.0428 | |
|
|
210
|
+
+---------|------------|------|-------------|----------|----+
|
|
211
|
+
| Total | | | 1,020,119.1 | | |
|
|
212
|
+
+=========+============+======+=============+==========+====+
|
|
213
|
+
|
|
214
|
+
|
|
215
|
+
<a id="org1e51988"></a>
|
|
216
|
+
|
|
217
|
+
## A Word About the Examples
|
|
218
|
+
|
|
219
|
+
When you install the `fat_table` gem, you have access to a program `ft_console`
|
|
220
|
+
which opens a `pry` session with `fat_table` loaded and the tables used in the
|
|
221
|
+
examples in this `README` defined as instance variables so you can experiment
|
|
222
|
+
with them. Because they are defined as instance variables, you have to write
|
|
223
|
+
`tab1` as `@tab1` in `ft_console`, but otherwise the examples should work.
|
|
224
|
+
|
|
225
|
+
The examples in this `README` file are executed as code blocks within the
|
|
226
|
+
`README.org` file, so they typically end with a call to `.to_aoa`. That causes
|
|
227
|
+
the table to be inserted into the file and formatted as a table. With
|
|
228
|
+
`ft_console`, you should instead display your tables with `.to_text` or
|
|
229
|
+
`.to_term`. These will return a string that you can print to the terminal with
|
|
230
|
+
`puts`.
|
|
231
|
+
|
|
232
|
+
To read in the table used in the Quick Start section above, you might do the
|
|
233
|
+
following:
|
|
234
|
+
|
|
235
|
+
$ ft_console[1] pry(main)> ls
|
|
236
|
+
ActiveSupport::ToJsonWithActiveSupportEncoder#methods: to_json
|
|
237
|
+
self.methods: inspect to_s
|
|
238
|
+
instance variables:
|
|
239
|
+
@aoa @tab1 @tab2 @tab_a @tab_b @tt
|
|
240
|
+
@data @tab1_str @tab2_str @tab_a_str @tab_b_str
|
|
241
|
+
locals: _ __ _dir_ _ex_ _file_ _in_ _out_ _pry_ lib str version
|
|
242
|
+
[2] pry(main)> table = FatTable.from_aoa(@data)
|
|
243
|
+
=> #<FatTable::Table:0x0055b40e6cd870
|
|
244
|
+
@boundaries=[],
|
|
245
|
+
@columns=
|
|
246
|
+
[#<FatTable::Column:0x0055b40e6cc948
|
|
247
|
+
@header=:date,
|
|
248
|
+
@items=
|
|
249
|
+
[Wed, 29 May 2013,
|
|
250
|
+
Thu, 02 May 2013,
|
|
251
|
+
Mon, 20 May 2013,
|
|
252
|
+
Thu, 23 May 2013,
|
|
253
|
+
Thu, 23 May 2013,
|
|
254
|
+
Mon, 20 May 2013,
|
|
255
|
+
Thu, 02 May 2013,
|
|
256
|
+
Wed, 29 May 2013,
|
|
257
|
+
Mon, 20 May 2013,
|
|
258
|
+
...
|
|
259
|
+
@items=["ENTITY3", "ENTITY1", "ENTITY3", "ENTITY3", "ENTITY3", "ENTITY3", "ENTITY1", "ENTITY3", "ENTITY3", "ENTITY3", "ENTITY3", "ENTITY3"],
|
|
260
|
+
@raw_header=:info,
|
|
261
|
+
@type="String">,
|
|
262
|
+
#<FatTable::Column:0x0055b40e6d2668 @header=:ok, @items=[false, true, false, true, true, true, true, true, true, true, true, false], @raw_header=:ok, @type="Boolean">]>
|
|
263
|
+
[3] pry(main)> puts table.to_text
|
|
264
|
+
+============+======+==========+==========+=========+=========+====+
|
|
265
|
+
| Date | Code | Raw | Shares | Price | Info | Ok |
|
|
266
|
+
+------------|------|----------|----------|---------|---------|----+
|
|
267
|
+
| 2013-05-29 | S | 15700.0 | 6601.85 | 24.779 | ENTITY3 | F |
|
|
268
|
+
| 2013-05-02 | P | 118186.4 | 118186.4 | 11.85 | ENTITY1 | T |
|
|
269
|
+
| 2013-05-20 | S | 12000.0 | 5046.0 | 28.2804 | ENTITY3 | F |
|
|
270
|
+
| 2013-05-23 | S | 8000.0 | 3364.0 | 27.1083 | ENTITY3 | T |
|
|
271
|
+
| 2013-05-23 | S | 39906.0 | 16780.47 | 25.1749 | ENTITY3 | T |
|
|
272
|
+
| 2013-05-20 | S | 85000.0 | 35742.5 | 28.3224 | ENTITY3 | T |
|
|
273
|
+
| 2013-05-02 | P | 795546.2 | 795546.2 | 1.185 | ENTITY1 | T |
|
|
274
|
+
| 2013-05-29 | S | 13459.0 | 5659.51 | 24.7464 | ENTITY3 | T |
|
|
275
|
+
| 2013-05-20 | S | 33302.0 | 14003.49 | 28.6383 | ENTITY3 | T |
|
|
276
|
+
| 2013-05-29 | S | 15900.0 | 6685.95 | 24.5802 | ENTITY3 | T |
|
|
277
|
+
| 2013-05-30 | S | 6679.0 | 2808.52 | 25.0471 | ENTITY3 | T |
|
|
278
|
+
| 2013-05-23 | S | 23054.0 | 9694.21 | 26.8015 | ENTITY3 | F |
|
|
279
|
+
+============+======+==========+==========+=========+=========+====+
|
|
280
|
+
=> nil
|
|
281
|
+
[4] pry(main)>
|
|
282
|
+
|
|
283
|
+
And if you use `.to_term`, you can see the effect of the color formatting
|
|
284
|
+
directives.
|
|
285
|
+
|
|
286
|
+
|
|
287
|
+
<a id="org7d48b5d"></a>
|
|
288
|
+
|
|
289
|
+
## Anatomy of a Table
|
|
290
|
+
|
|
291
|
+
|
|
292
|
+
<a id="org4a6c98f"></a>
|
|
293
|
+
|
|
294
|
+
### Columns
|
|
295
|
+
|
|
296
|
+
`FatTable::Table` objects consist of an array of `FatTable::Column` objects.
|
|
297
|
+
Each `Column` has a header, a type, and an array of items, all of the given type
|
|
298
|
+
or nil. There are only five permissible types for a `Column`:
|
|
299
|
+
|
|
300
|
+
1. **Boolean** (for holding ruby `TrueClass` and `FalseClass` objects),
|
|
301
|
+
2. **DateTime** (for holding ruby `DateTime` or `Date` objects),
|
|
302
|
+
3. **Numeric** (for holding ruby `Integer`, `Rational`, or `BigDecimal` objects),
|
|
303
|
+
4. **String** (for ruby `String` objects), or
|
|
304
|
+
5. **NilClass** (for the undetermined column type).
|
|
305
|
+
|
|
306
|
+
When a `Table` is constructed from an external source, all `Columns` start out
|
|
307
|
+
having a type of `NilClass`, that is, their type is as yet undetermined. When a
|
|
308
|
+
string or object of one of the four determined types is added to a `Column`, it
|
|
309
|
+
fixes the type of the column and all further items added to the `Column` must
|
|
310
|
+
either be `nil` (indicating no value) or be capable of being coerced to the
|
|
311
|
+
column’s type. Otherwise, `FatTable` raises an exception.
|
|
312
|
+
|
|
313
|
+
Items of input must be either one of the permissible ruby objects or strings. If
|
|
314
|
+
they are strings, `FatTable` attempts to parse them as one of the permissible
|
|
315
|
+
types as follows:
|
|
316
|
+
|
|
317
|
+
- **Boolean:** the strings, `'t'`, `'true'`, `'yes'`, or `'y'`, regardless of
|
|
318
|
+
case, are interpreted as `TrueClass` and the strings, `'f'`, `'false'`,
|
|
319
|
+
`'no'`, or `'n'`, regardless of case, are interpreted as `FalseClass`, in
|
|
320
|
+
either case resulting in a Boolean column. Empty strings in a column
|
|
321
|
+
already having a Boolean type are converted to `nil`.
|
|
322
|
+
- **DateTime:** strings that contain patterns of `'yyyy-mm-dd'` or `'yyyy/mm/dd'`
|
|
323
|
+
or `'mm-dd-yyy'` or `'mm/dd/yyyy'` or any of the foregoing with an added
|
|
324
|
+
`'Thh:mm:ss'` or `'Thh:mm'` will be interpreted as a `DateTime` or a `Date`
|
|
325
|
+
(if there are no sub-day time components present). The number of digits in
|
|
326
|
+
the month and day can be one or two, but the year component must be four
|
|
327
|
+
digits. Any time components are valid if they can be properly interpreted
|
|
328
|
+
by `DateTime.parse`. Org mode timestamps (any of the foregoing surrounded
|
|
329
|
+
by square ’`[]`’ or pointy ’`<>`’ brackets), active or inactive, are valid
|
|
330
|
+
input strings for `DateTime` columns. Empty strings in a column already
|
|
331
|
+
having the `DateTime` type are converted to `nil`.
|
|
332
|
+
- **Numeric:** all commas `','`, underscores, `'_'`, and `'$'` dollar signs (or
|
|
333
|
+
other currency symbol as set by `FatTable.currency_symbol` are removed from
|
|
334
|
+
the string and if the remaining string can be interpreted as a `Numeric`,
|
|
335
|
+
it will be. It is interpreted as an `Integer` if there are no decimal
|
|
336
|
+
places in the remaining string, as a `Rational` if the string has the form
|
|
337
|
+
’`<number>:<number>`’ or ’`<number>/<number>`’, or as a `BigDecimal` if
|
|
338
|
+
there is a decimal point in the remaining string. Empty strings in a column
|
|
339
|
+
already having the Numeric type are converted to nil.
|
|
340
|
+
- **String:** if all else fails, `FatTable` applies `#to_s` to the input value
|
|
341
|
+
and, treats it as an item of type `String`. Empty strings in a column
|
|
342
|
+
already having the `String` type are kept as empty strings.
|
|
343
|
+
- **NilClass:** until the input contains a non-blank string that can be parsed as
|
|
344
|
+
one of the other types, it has this type, meaning that the type is still
|
|
345
|
+
open. A column comprised completely of blank strings or `nils` will retain
|
|
346
|
+
the `NilClass` type.
|
|
347
|
+
|
|
348
|
+
|
|
349
|
+
<a id="org37bbf47"></a>
|
|
350
|
+
|
|
351
|
+
### Headers
|
|
352
|
+
|
|
353
|
+
Headers for the columns are formed from the input. No two columns in a table can
|
|
354
|
+
have the same header. Headers in the input are converted to symbols by
|
|
355
|
+
|
|
356
|
+
- converting the header to a string with `#to_s`,
|
|
357
|
+
- converting any run of blanks to an underscore `_`,
|
|
358
|
+
- removing any characters that are not letters, numbers, or underscores, and
|
|
359
|
+
- lowercasing all remaining letters
|
|
360
|
+
|
|
361
|
+
Thus, a header of `'Date'` becomes `:date`, a header of `'Id Number'` becomes,
|
|
362
|
+
`:id_number`, etc. When referring to a column in code, you must use the symbol
|
|
363
|
+
form of the header.
|
|
364
|
+
|
|
365
|
+
If no sensible headers can be discerned from the input, headers of the form
|
|
366
|
+
`:col_1`, `:col_2`, etc., are synthesized.
|
|
367
|
+
|
|
368
|
+
|
|
369
|
+
<a id="org1c03cc1"></a>
|
|
370
|
+
|
|
371
|
+
### Groups
|
|
372
|
+
|
|
373
|
+
The rows of a `FatTable` table can be sub-divided into groups, either from
|
|
374
|
+
markers in the input or as a result of certain operations. There is only one
|
|
375
|
+
level of grouping, so `FatTable` has no concept of sub-groups. Groups can be
|
|
376
|
+
shown on output with rules or “hlines” that underline the last row in each
|
|
377
|
+
group, and you can decorate the output with group footers that summarize the
|
|
378
|
+
columns in each group.
|
|
379
|
+
|
|
380
|
+
|
|
381
|
+
<a id="orgbf0e735"></a>
|
|
382
|
+
|
|
383
|
+
## Constructing Tables
|
|
384
|
+
|
|
385
|
+
|
|
386
|
+
<a id="org80c41f5"></a>
|
|
387
|
+
|
|
388
|
+
### Empty Tables
|
|
389
|
+
|
|
390
|
+
You can create an empty table with `FatTable.new`, and then add rows with the
|
|
391
|
+
`<<` operator and a Hash:
|
|
392
|
+
|
|
393
|
+
tab = FatTable.new
|
|
394
|
+
tab << { a: 1, b: 2, c: "<2017-01-21>', d: 'f', e: '' }
|
|
395
|
+
tab << { a: 3.14, b: 2.17, c: '[2016-01-21 Thu]', d: 'Y', e: nil }
|
|
396
|
+
tab.to_aoa
|
|
397
|
+
|
|
398
|
+
After this, the table will have column headers `:a`, `:b`, `:c`, `:d`, and `:e`.
|
|
399
|
+
Column, `:a` and `:b` will have type Numeric, column `:c` will have type
|
|
400
|
+
`DateTime`, and column `:d` will have type `Boolean`. Column `:e` will still
|
|
401
|
+
have an open type. Notice that dates in the input can be wrapped in brackets as
|
|
402
|
+
in org-mode time stamps.
|
|
403
|
+
|
|
404
|
+
|
|
405
|
+
<a id="org681a599"></a>
|
|
406
|
+
|
|
407
|
+
### From CSV or Org Mode files or strings
|
|
408
|
+
|
|
409
|
+
Tables can also be read from `.csv` files or files containing `org-mode` tables.
|
|
410
|
+
In the case of org-mode files, `FatTable` skips through the file until it finds
|
|
411
|
+
a line that look like a table, that is, it begins with any number of spaces
|
|
412
|
+
followed by `|-`. Only the first table in an `.org` file is read.
|
|
413
|
+
|
|
414
|
+
For both `.csv` and `.org` files, the first row in the tables is taken as the
|
|
415
|
+
header row, and the headers are converted to symbols as described above.
|
|
416
|
+
|
|
417
|
+
tab1 = FatTable.from_csv_file('~/data.csv')
|
|
418
|
+
tab2 = FatTable.from_org_file('~/project.org')
|
|
419
|
+
|
|
420
|
+
csv_body = <<-EOS
|
|
421
|
+
Ref,Date,Code,RawShares,Shares,Price,Info
|
|
422
|
+
1,2006-05-02,P,5000,5000,8.6000,2006-08-09-1-I
|
|
423
|
+
2,2006-05-03,P,5000,5000,8.4200,2006-08-09-1-I
|
|
424
|
+
3,2006-05-04,P,5000,5000,8.4000,2006-08-09-1-I
|
|
425
|
+
4,2006-05-10,P,8600,8600,8.0200,2006-08-09-1-D
|
|
426
|
+
5,2006-05-12,P,10000,10000,7.2500,2006-08-09-1-D
|
|
427
|
+
6,2006-05-12,P,2000,2000,6.7400,2006-08-09-1-I
|
|
428
|
+
EOS
|
|
429
|
+
|
|
430
|
+
tab3 = FatTable.from_csv_string(csv_body)
|
|
431
|
+
|
|
432
|
+
org_body = <<-EOS
|
|
433
|
+
.* Smith Transactions
|
|
434
|
+
:PROPERTIES:
|
|
435
|
+
:TABLE_EXPORT_FILE: smith.csv
|
|
436
|
+
:END:
|
|
437
|
+
|
|
438
|
+
#+TBLNAME: smith_tab
|
|
439
|
+
| Ref | Date | Code | Raw | Shares | Price | Info |
|
|
440
|
+
|-----|------------|------|---------|--------|----------|---------|
|
|
441
|
+
| 29 | 2013-05-02 | P | 795,546 | 2,609 | 1.18500 | ENTITY1 |
|
|
442
|
+
| 30 | 2013-05-02 | P | 118,186 | 388 | 11.85000 | ENTITY1 |
|
|
443
|
+
| 31 | 2013-05-02 | P | 340,948 | 1,926 | 1.18500 | ENTITY2 |
|
|
444
|
+
| 32 | 2013-05-02 | P | 50,651 | 286 | 11.85000 | ENTITY2 |
|
|
445
|
+
| 33 | 2013-05-20 | S | 12,000 | 32 | 28.28040 | ENTITY3 |
|
|
446
|
+
| 34 | 2013-05-20 | S | 85,000 | 226 | 28.32240 | ENTITY3 |
|
|
447
|
+
| 35 | 2013-05-20 | S | 33,302 | 88 | 28.63830 | ENTITY3 |
|
|
448
|
+
| 36 | 2013-05-23 | S | 8,000 | 21 | 27.10830 | ENTITY3 |
|
|
449
|
+
| 37 | 2013-05-23 | S | 23,054 | 61 | 26.80150 | ENTITY3 |
|
|
450
|
+
| 38 | 2013-05-23 | S | 39,906 | 106 | 25.17490 | ENTITY3 |
|
|
451
|
+
| 39 | 2013-05-29 | S | 13,459 | 36 | 24.74640 | ENTITY3 |
|
|
452
|
+
| 40 | 2013-05-29 | S | 15,700 | 42 | 24.77900 | ENTITY3 |
|
|
453
|
+
| 41 | 2013-05-29 | S | 15,900 | 42 | 24.58020 | ENTITY3 |
|
|
454
|
+
| 42 | 2013-05-30 | S | 6,679 | 18 | 25.04710 | ENTITY3 |
|
|
455
|
+
|
|
456
|
+
.* Another Heading
|
|
457
|
+
EOS
|
|
458
|
+
|
|
459
|
+
tab4 = FatTable.from_org_string(org_body)
|
|
460
|
+
|
|
461
|
+
|
|
462
|
+
<a id="org4f683cf"></a>
|
|
463
|
+
|
|
464
|
+
### From Arrays of Arrays
|
|
465
|
+
|
|
466
|
+
You can also initialize a table directly from ruby data structures. You can, for
|
|
467
|
+
example, build a table from an array of arrays:
|
|
468
|
+
|
|
469
|
+
aoa = [
|
|
470
|
+
['Ref', 'Date', 'Code', 'Raw', 'Shares', 'Price', 'Info', 'Bool'],
|
|
471
|
+
[1, '2013-05-02', 'P', 795_546.20, 795_546.2, 1.1850, 'ENTITY1', 'T'],
|
|
472
|
+
[2, '2013-05-02', 'P', 118_186.40, 118_186.4, 11.8500, 'ENTITY1', 'T'],
|
|
473
|
+
[7, '2013-05-20', 'S', 12_000.00, 5046.00, 28.2804, 'ENTITY3', 'F'],
|
|
474
|
+
[8, '2013-05-20', 'S', 85_000.00, 35_742.50, 28.3224, 'ENTITY3', 'T'],
|
|
475
|
+
[9, '2013-05-20', 'S', 33_302.00, 14_003.49, 28.6383, 'ENTITY3', 'T'],
|
|
476
|
+
[10, '2013-05-23', 'S', 8000.00, 3364.00, 27.1083, 'ENTITY3', 'T'],
|
|
477
|
+
[11, '2013-05-23', 'S', 23_054.00, 9694.21, 26.8015, 'ENTITY3', 'F'],
|
|
478
|
+
[12, '2013-05-23', 'S', 39_906.00, 16_780.47, 25.1749, 'ENTITY3', 'T'],
|
|
479
|
+
[13, '2013-05-29', 'S', 13_459.00, 5659.51, 24.7464, 'ENTITY3', 'T'],
|
|
480
|
+
[14, '2013-05-29', 'S', 15_700.00, 6601.85, 24.7790, 'ENTITY3', 'F'],
|
|
481
|
+
[15, '2013-05-29', 'S', 15_900.00, 6685.95, 24.5802, 'ENTITY3', 'T'],
|
|
482
|
+
[16, '2013-05-30', 'S', 6_679.00, 2808.52, 25.0471, 'ENTITY3', 'T']
|
|
483
|
+
]
|
|
484
|
+
tab = FatTable.from_aoa(aoa)
|
|
485
|
+
|
|
486
|
+
Notice that the values can either be ruby objects, such as the Integer `85_000`,
|
|
487
|
+
or strings that can be parsed into one of the permissible column types.
|
|
488
|
+
|
|
489
|
+
This method of building a table, `.from_aoa`, is particularly useful in dealing
|
|
490
|
+
with Emacs org-mode code blocks. Tables in org-mode are passed to code blocks as
|
|
491
|
+
arrays of arrays. Likewise, a result of a code block in the form of an array of
|
|
492
|
+
arrays is displayed as an org-mode table:
|
|
493
|
+
|
|
494
|
+
#+NAME: trades1
|
|
495
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | LP | QP | IPLP | IPQP |
|
|
496
|
+
|------|------------|------|--------|-----|------|--------|-------|--------|--------|--------|
|
|
497
|
+
| T001 | 2016-11-01 | P | 7.7000 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
498
|
+
| T002 | 2016-11-01 | P | 7.7500 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
499
|
+
| T003 | 2016-11-01 | P | 7.5000 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
500
|
+
| T004 | 2016-11-01 | S | 7.5500 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
501
|
+
| T005 | 2016-11-01 | S | 7.5000 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
502
|
+
| T006 | 2016-11-01 | S | 7.6000 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
503
|
+
| T007 | 2016-11-01 | S | 7.6500 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
504
|
+
| T008 | 2016-11-01 | P | 7.6500 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
505
|
+
| T009 | 2016-11-01 | P | 7.6000 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
506
|
+
| T010 | 2016-11-01 | P | 7.5500 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
507
|
+
| T011 | 2016-11-02 | P | 7.4250 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
508
|
+
| T012 | 2016-11-02 | P | 7.5500 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
509
|
+
| T013 | 2016-11-02 | P | 7.3500 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
510
|
+
| T014 | 2016-11-02 | P | 7.4500 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
511
|
+
| T015 | 2016-11-02 | P | 7.7500 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
512
|
+
| T016 | 2016-11-02 | P | 8.2500 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
513
|
+
|
|
514
|
+
#+HEADER: :colnames no
|
|
515
|
+
:#+BEGIN_SRC ruby :var tab=trades1
|
|
516
|
+
require 'fat_table'
|
|
517
|
+
tab = FatTable.from_aoa(tab).where('shares > 500')
|
|
518
|
+
tab.to_aoa
|
|
519
|
+
:#+END_SRC
|
|
520
|
+
|
|
521
|
+
#+RESULTS:
|
|
522
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
523
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
524
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
525
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
526
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
527
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
528
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
529
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
530
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
531
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
532
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
533
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
534
|
+
|
|
535
|
+
This example illustrates several things:
|
|
536
|
+
|
|
537
|
+
1. The named org-mode table, `trades1`, can be passed into a ruby code block
|
|
538
|
+
using the `:var tab=trades1` header argument to the code block; that makes
|
|
539
|
+
the variable `tab` available to the code block as an array of arrays, which
|
|
540
|
+
`FatTable` then uses to initialize the table.
|
|
541
|
+
2. The code block requires that you set `:colnames no` in the header arguments.
|
|
542
|
+
This suppresses org-mode’s own processing of the header line so that
|
|
543
|
+
`FatTable` can see the headers. Failure to do this will cause an error.
|
|
544
|
+
3. The table is subjected to some processing, in this case selecting those rows
|
|
545
|
+
where the number of shares is greater than 500. More on that later.
|
|
546
|
+
4. `FatTable` passes back to org-mode an array of arrays using the `.to_aoa`
|
|
547
|
+
method. In an `org-mode` buffer, these are rendered as tables. We’ll often
|
|
548
|
+
apply `.to_aoa` at the end of example blocks to render the results inside
|
|
549
|
+
this `README.org` file. As we’ll see below, this method can also take a block
|
|
550
|
+
to which formatting directives and footers can be attached.
|
|
551
|
+
|
|
552
|
+
|
|
553
|
+
<a id="org7980800"></a>
|
|
554
|
+
|
|
555
|
+
### From Arrays of Hashes
|
|
556
|
+
|
|
557
|
+
A second ruby data structure that can be used to initialize a `FatTable` table
|
|
558
|
+
is an array of ruby Hashes. Each hash represents a row of the table, and the
|
|
559
|
+
headers of the table are take from the keys of the hashes. Accordingly, all the
|
|
560
|
+
hashes should have the same keys.
|
|
561
|
+
|
|
562
|
+
This same method can in fact take an array of any objects that can be converted
|
|
563
|
+
to a Hash with the `#to_h` method, so you can use an array of your own objects
|
|
564
|
+
to initialize a table, provided that you define a suitable `#to_h` method for
|
|
565
|
+
the objects’ class.
|
|
566
|
+
|
|
567
|
+
aoh = [
|
|
568
|
+
{ ref: 'T001', date: '2016-11-01', code: 'P', price: '7.7000', shares: 100 },
|
|
569
|
+
{ ref: 'T002', date: '2016-11-01', code: 'P', price: 7.7500, shares: 200 },
|
|
570
|
+
{ ref: 'T003', date: '2016-11-01', code: 'P', price: 7.5000, shares: 800 },
|
|
571
|
+
{ ref: 'T004', date: '2016-11-01', code: 'S', price: 7.5500, shares: 6811 },
|
|
572
|
+
{ ref: 'T005', date: Date.today, code: 'S', price: 7.5000, shares: 4000 },
|
|
573
|
+
{ ref: 'T006', date: '2016-11-01', code: 'S', price: 7.6000, shares: 1000 },
|
|
574
|
+
{ ref: 'T007', date: '2016-11-01', code: 'S', price: 7.6500, shares: 200 },
|
|
575
|
+
{ ref: 'T008', date: '2016-11-01', code: 'P', price: 7.6500, shares: 2771 },
|
|
576
|
+
{ ref: 'T009', date: '2016-11-01', code: 'P', price: 7.6000, shares: 9550 },
|
|
577
|
+
{ ref: 'T010', date: '2016-11-01', code: 'P', price: 7.5500, shares: 3175 },
|
|
578
|
+
{ ref: 'T011', date: '2016-11-02', code: 'P', price: 7.4250, shares: 100 },
|
|
579
|
+
{ ref: 'T012', date: '2016-11-02', code: 'P', price: 7.5500, shares: 4700 },
|
|
580
|
+
{ ref: 'T013', date: '2016-11-02', code: 'P', price: 7.3500, shares: 53100 },
|
|
581
|
+
{ ref: 'T014', date: '2016-11-02', code: 'P', price: 7.4500, shares: 5847 },
|
|
582
|
+
{ ref: 'T015', date: '2016-11-02', code: 'P', price: 7.7500, shares: 500 },
|
|
583
|
+
{ ref: 'T016', date: '2016-11-02', code: 'P', price: 8.2500, shares: 100 }
|
|
584
|
+
]
|
|
585
|
+
tab = FatTable.from_aoh(aoh)
|
|
586
|
+
|
|
587
|
+
Notice, again, that the values can either be ruby objects, such as `Date.today`,
|
|
588
|
+
or strings that can parsed into one of the permissible column types.
|
|
589
|
+
|
|
590
|
+
|
|
591
|
+
<a id="orgdab2ec1"></a>
|
|
592
|
+
|
|
593
|
+
### From SQL queries
|
|
594
|
+
|
|
595
|
+
Another way to initialize a `FatTable` table is with the results of a SQL query.
|
|
596
|
+
`FatTable` uses the `sequel` gem to query databases. You must first set the
|
|
597
|
+
database parameters to be used for the queries.
|
|
598
|
+
|
|
599
|
+
# This automatically requires sequel.
|
|
600
|
+
require 'fat_table'
|
|
601
|
+
FatTable.set_db(driver: 'Pg',
|
|
602
|
+
database: 'XXX_development',
|
|
603
|
+
user: 'dtd',
|
|
604
|
+
password: 'slflpowert',
|
|
605
|
+
host: 'localhost',
|
|
606
|
+
socket: '/tmp/.s.PGSQL.5432')
|
|
607
|
+
tab = FatTable.from_sql('select * from trades;')
|
|
608
|
+
|
|
609
|
+
Some of the parameters to the `.set_db` function have defaults. The driver
|
|
610
|
+
defaults to `'Pg'` for postgresql and the socket defaults to
|
|
611
|
+
`/tmp/.s.PGSQL.5432` if the host is ’localhost’, which it is by default. If the
|
|
612
|
+
host is not `'localhost'`, the dsn uses a port rather than a socket and defaults
|
|
613
|
+
to port `'5432'`. While user and password default to nil, the database parameter
|
|
614
|
+
is required.
|
|
615
|
+
|
|
616
|
+
The `.set_db` function need only be called once, and the database handle it
|
|
617
|
+
creates will be used for all subsequent `.from_sql` calls until `.set_db` is
|
|
618
|
+
called again.
|
|
619
|
+
|
|
620
|
+
Alternatively, you can build the `Sequel` connection with `Sequel.connect` or
|
|
621
|
+
with adapter-specific `Sequel` connection methods and let `FatTable` know to use
|
|
622
|
+
that connection:
|
|
623
|
+
|
|
624
|
+
require 'fat_table'
|
|
625
|
+
FatTable.db = Sequel.connect('postgres://user:password@localhost/dbname')
|
|
626
|
+
FatTable.db = Sequel.ado(conn_string: 'Provider=Microsoft.ACE.OLEDB.12.0;Data Source=drive:\path\filename.accdb')
|
|
627
|
+
|
|
628
|
+
Consult `Sequel's` documentation for details on its connection methods.
|
|
629
|
+
<http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html>
|
|
630
|
+
|
|
631
|
+
|
|
632
|
+
<a id="orgeb97e36"></a>
|
|
633
|
+
|
|
634
|
+
### Marking Groups in Input
|
|
635
|
+
|
|
636
|
+
The `.from_aoa` and `.from_aoh` functions take an optional keyword parameter
|
|
637
|
+
`hlines:` that, if set to `true`, causes them to mark group boundaries in the
|
|
638
|
+
table wherever a row Array (for `.from_aoa`) or Hash (for `.from_aoh`) is
|
|
639
|
+
followed by a `nil`. Each boundary means that the rows above it and after the
|
|
640
|
+
header or prior group boundary all belong to a group. By default `hlines` is
|
|
641
|
+
false for both functions so neither expects hlines in its input.
|
|
642
|
+
|
|
643
|
+
In the case of `.from_aoa`, if `hlines:` is set true, the input must also
|
|
644
|
+
include a `nil` in the second element of the outer array to indicate that the
|
|
645
|
+
first row is to be used as headers. Otherwise, it will synthesize headers of
|
|
646
|
+
the form `:col_1`, `:col_2`, … `:col_n`.
|
|
647
|
+
|
|
648
|
+
In org mode table text passed to `.from_org_file` and `.from_org_string`, you
|
|
649
|
+
*must* mark the header row by following it with an hrule and you *may* mark
|
|
650
|
+
group boundaries with an hrule. In org mode tables, hlines are table rows
|
|
651
|
+
beginning with something like ’`|---`’. The `.from_org_...` functions always
|
|
652
|
+
recognizes hlines in the input, so it takes no `hlines:` keyword parameter.
|
|
653
|
+
|
|
654
|
+
|
|
655
|
+
<a id="orgf9cb237"></a>
|
|
656
|
+
|
|
657
|
+
## Accessing Parts of Tables
|
|
658
|
+
|
|
659
|
+
|
|
660
|
+
<a id="org4453cea"></a>
|
|
661
|
+
|
|
662
|
+
### Rows
|
|
663
|
+
|
|
664
|
+
A `FatTable` table is an Enumerable, yielding each row of the table as a Hash
|
|
665
|
+
keyed on the header symbols. The method `Table#rows` returns an Array of the
|
|
666
|
+
rows as Hashes as well.
|
|
667
|
+
|
|
668
|
+
You can also use indexing to access a row of the table by number. Using an
|
|
669
|
+
integer index returns a Hash of the given row. Thus, `tab[20]` returns the 21st
|
|
670
|
+
data row of the table, while `tab[0]` returns the first row and tab[-1] returns
|
|
671
|
+
the last row.
|
|
672
|
+
|
|
673
|
+
|
|
674
|
+
<a id="org8a6dd85"></a>
|
|
675
|
+
|
|
676
|
+
### Columns
|
|
677
|
+
|
|
678
|
+
If the index provided to `[]` is a string or a symbol, it returns an Array of
|
|
679
|
+
the items of the column with that header. Thus, `tab[:ref]` returns an Array of
|
|
680
|
+
all the items of the table’s `:ref` column.
|
|
681
|
+
|
|
682
|
+
|
|
683
|
+
<a id="orgcc87a8b"></a>
|
|
684
|
+
|
|
685
|
+
### Cells
|
|
686
|
+
|
|
687
|
+
The two forms of indexing can be combined to access individual cells of the
|
|
688
|
+
table:
|
|
689
|
+
|
|
690
|
+
tab[13] # => Hash of the 14th row
|
|
691
|
+
tab[:date] # => Array of all Dates in the :date column
|
|
692
|
+
tab[13][:date] # => The Date in the 14th row
|
|
693
|
+
tab[:date][13] # => The Date in the 14th row; indexes can be in either order.
|
|
694
|
+
|
|
695
|
+
|
|
696
|
+
<a id="org4a41de4"></a>
|
|
697
|
+
|
|
698
|
+
### Other table attributes
|
|
699
|
+
|
|
700
|
+
tab.headers # => an Array of the headers in symbol form
|
|
701
|
+
tab.types # => a Hash mapping headers to column types
|
|
702
|
+
tab.size # => the number of rows in the table
|
|
703
|
+
tab.width # => the number of columns in the table
|
|
704
|
+
tab.empty? # => is the table empty?
|
|
705
|
+
tab.column?(head) # => does the table have a column with the given header?
|
|
706
|
+
tab.groups # => return an Array of the table's groups as Arrays of row Hashes.
|
|
707
|
+
|
|
708
|
+
|
|
709
|
+
<a id="org731fd13"></a>
|
|
710
|
+
|
|
711
|
+
## Operations on Tables
|
|
712
|
+
|
|
713
|
+
Once you have one or more tables, you will likely want to perform operations on
|
|
714
|
+
them. The operations provided by `FatTable` are the subject of this section.
|
|
715
|
+
Before getting into the operations, though, there are a couple of issues that
|
|
716
|
+
cut across all or many of the operations.
|
|
717
|
+
|
|
718
|
+
First, tables are by and large immutable objects. Each operation creates a new
|
|
719
|
+
table without affecting the input tables. The only exception is the `degroup!`
|
|
720
|
+
operation, which mutates the receiver table by removing its group boundaries.
|
|
721
|
+
|
|
722
|
+
Second, because each operation returns a `FatTable::Table` object, the
|
|
723
|
+
operations are chainable.
|
|
724
|
+
|
|
725
|
+
Third, `FatTable::Table` objects can have “groups” of rows within the table.
|
|
726
|
+
These can be decorated with hlines and group footers on output. Some of these
|
|
727
|
+
operations result in marking group boundaries in the result table, others remove
|
|
728
|
+
group boundaries that may have existed in the input table. Operations that
|
|
729
|
+
either create or remove groups will be noted below.
|
|
730
|
+
|
|
731
|
+
Finally, the operations are for the most part patterned on SQL table operations,
|
|
732
|
+
but when expressions play a role, you write them using ruby syntax rather than
|
|
733
|
+
SQL.
|
|
734
|
+
|
|
735
|
+
|
|
736
|
+
<a id="orga96ca08"></a>
|
|
737
|
+
|
|
738
|
+
### Example Input Table
|
|
739
|
+
|
|
740
|
+
For illustration purposes assume that the following tables are read into ruby
|
|
741
|
+
variables called ’`tab1`’ and ’`tab2`. We have given the table groups, marked by
|
|
742
|
+
the hlines below, and included some duplicate rows to illustrate the effect of
|
|
743
|
+
certain operations on groups and duplicates.
|
|
744
|
+
|
|
745
|
+
require 'fat_table'
|
|
746
|
+
|
|
747
|
+
tab1_str = <<-EOS
|
|
748
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | LP | QP | IPLP | IPQP |
|
|
749
|
+
|------|------------------|------|--------|-----|------|--------|------|-------|--------|--------|
|
|
750
|
+
| T001 | [2016-11-01 Tue] | P | 7.7000 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
751
|
+
| T002 | [2016-11-01 Tue] | P | 7.7500 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
752
|
+
| T003 | [2016-11-01 Tue] | P | 7.5000 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
753
|
+
| T003 | [2016-11-01 Tue] | P | 7.5000 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
754
|
+
|------|------------------|------|--------|-----|------|--------|------|-------|--------|--------|
|
|
755
|
+
| T004 | [2016-11-01 Tue] | S | 7.5500 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
756
|
+
| T005 | [2016-11-01 Tue] | S | 7.5000 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
757
|
+
| T006 | [2016-11-01 Tue] | S | 7.6000 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
758
|
+
| T006 | [2016-11-01 Tue] | S | 7.6000 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
759
|
+
| T007 | [2016-11-01 Tue] | S | 7.6500 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
760
|
+
| T008 | [2016-11-01 Tue] | P | 7.6500 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
761
|
+
| T009 | [2016-11-01 Tue] | P | 7.6000 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
762
|
+
|------|------------------|------|--------|-----|------|--------|------|-------|--------|--------|
|
|
763
|
+
| T010 | [2016-11-01 Tue] | P | 7.5500 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
764
|
+
| T011 | [2016-11-02 Wed] | P | 7.4250 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
765
|
+
| T012 | [2016-11-02 Wed] | P | 7.5500 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
766
|
+
| T012 | [2016-11-02 Wed] | P | 7.5500 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
767
|
+
| T013 | [2016-11-02 Wed] | P | 7.3500 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
768
|
+
|------|------------------|------|--------|-----|------|--------|------|-------|--------|--------|
|
|
769
|
+
| T014 | [2016-11-02 Wed] | P | 7.4500 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
770
|
+
| T015 | [2016-11-02 Wed] | P | 7.7500 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
771
|
+
| T016 | [2016-11-02 Wed] | P | 8.2500 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
772
|
+
EOS
|
|
773
|
+
|
|
774
|
+
tab2_str = <<-EOS
|
|
775
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | LP | QP | IPLP | IPQP |
|
|
776
|
+
|------|------------------|------|--------|-----|------|--------|-------|------|--------|--------|
|
|
777
|
+
| T003 | [2016-11-01 Tue] | P | 7.5000 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
778
|
+
| T003 | [2016-11-01 Tue] | P | 7.5000 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
779
|
+
| T017 | [2016-11-01 Tue] | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
780
|
+
|------|------------------|------|--------|-----|------|--------|-------|------|--------|--------|
|
|
781
|
+
| T018 | [2016-11-01 Tue] | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
782
|
+
| T018 | [2016-11-01 Tue] | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
783
|
+
| T006 | [2016-11-01 Tue] | S | 7.6000 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
784
|
+
| T007 | [2016-11-01 Tue] | S | 7.6500 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
785
|
+
|------|------------------|------|--------|-----|------|--------|-------|------|--------|--------|
|
|
786
|
+
| T014 | [2016-11-02 Wed] | P | 7.4500 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
787
|
+
| T015 | [2016-11-02 Wed] | P | 7.7500 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
788
|
+
| T015 | [2016-11-02 Wed] | P | 7.7500 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
789
|
+
| T016 | [2016-11-02 Wed] | P | 8.2500 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
790
|
+
|------|------------------|------|--------|-----|------|--------|-------|------|--------|--------|
|
|
791
|
+
| T019 | [2017-01-15 Sun] | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
792
|
+
| T020 | [2017-01-19 Thu] | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
793
|
+
| T021 | [2017-01-23 Mon] | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
794
|
+
| T021 | [2017-01-23 Mon] | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
795
|
+
EOS
|
|
796
|
+
|
|
797
|
+
tab1 = FatTable.from_org_string(tab1_str)
|
|
798
|
+
tab2 = FatTable.from_org_string(tab2_str)
|
|
799
|
+
|
|
800
|
+
|
|
801
|
+
<a id="orga0c49b3"></a>
|
|
802
|
+
|
|
803
|
+
### Select
|
|
804
|
+
|
|
805
|
+
With the `select` method, you can select which existing columns should appear in
|
|
806
|
+
the output table and create new columns in the output table that are a function
|
|
807
|
+
of existing and new columns.
|
|
808
|
+
|
|
809
|
+
1. Selecting Existing Columns
|
|
810
|
+
|
|
811
|
+
Here we select three existing columns by simply passing header symbols in the
|
|
812
|
+
order we want them to appear in the output. Thus, one use of `select` is to
|
|
813
|
+
filter and permute the order of existing columns. The `select` method preserves
|
|
814
|
+
any group boundaries present in the input table.
|
|
815
|
+
|
|
816
|
+
tab1.select(:price, :ref, :shares).to_aoa
|
|
817
|
+
|
|
818
|
+
| Price | Ref | Shares |
|
|
819
|
+
|-------|------|--------|
|
|
820
|
+
| 7.7 | T001 | 100 |
|
|
821
|
+
| 7.75 | T002 | 200 |
|
|
822
|
+
| 7.5 | T003 | 800 |
|
|
823
|
+
| 7.5 | T003 | 800 |
|
|
824
|
+
|-------|------|--------|
|
|
825
|
+
| 7.55 | T004 | 6811 |
|
|
826
|
+
| 7.5 | T005 | 4000 |
|
|
827
|
+
| 7.6 | T006 | 1000 |
|
|
828
|
+
| 7.6 | T006 | 1000 |
|
|
829
|
+
| 7.65 | T007 | 200 |
|
|
830
|
+
| 7.65 | T008 | 2771 |
|
|
831
|
+
| 7.6 | T009 | 9550 |
|
|
832
|
+
|-------|------|--------|
|
|
833
|
+
| 7.55 | T010 | 3175 |
|
|
834
|
+
| 7.425 | T011 | 100 |
|
|
835
|
+
| 7.55 | T012 | 4700 |
|
|
836
|
+
| 7.55 | T012 | 4700 |
|
|
837
|
+
| 7.35 | T013 | 53100 |
|
|
838
|
+
|-------|------|--------|
|
|
839
|
+
| 7.45 | T014 | 5847 |
|
|
840
|
+
| 7.75 | T015 | 500 |
|
|
841
|
+
| 8.25 | T016 | 100 |
|
|
842
|
+
|
|
843
|
+
2. Adding New Columns
|
|
844
|
+
|
|
845
|
+
More interesting is that `select` can take hash-like keyword arguments after the
|
|
846
|
+
symbol arguments to create new columns in the output as functions of other
|
|
847
|
+
columns. For each hash-like parameter, the keyword given must be a symbol, which
|
|
848
|
+
becomes the header for the new column, and the value must be either: (1) a
|
|
849
|
+
symbol representing an existing column, which has the effect of renaming an
|
|
850
|
+
existing column, or (2) a string representing a ruby expression for the value of
|
|
851
|
+
a new column.
|
|
852
|
+
|
|
853
|
+
Within the string expression, the names of existing or already-specified columns
|
|
854
|
+
are available as local variables, as well as the instance variables ’@row’ and
|
|
855
|
+
’@group’. So for our example table, the string expressions for new columns have
|
|
856
|
+
access to local variables `ref`, `date`, `code`, `price`, `g10`, `qp10`,
|
|
857
|
+
`shares`, `lp`, `qp`, `iplp`, and `ipqp` as well as the instance variables
|
|
858
|
+
`@row` and `@group`. The local variables are set to the values of the cell in
|
|
859
|
+
their respective columns for each row in the input table and the instance
|
|
860
|
+
variables are set the number of the current row and group respectively.
|
|
861
|
+
|
|
862
|
+
For example, if we want to rename the `:date` column and add a new column to
|
|
863
|
+
compute the cost of shares, we could do the following:
|
|
864
|
+
|
|
865
|
+
tab1.select(:ref, :price, :shares, traded_on: :date, cost: 'price * shares').to_aoa
|
|
866
|
+
|
|
867
|
+
| Ref | Price | Shares | Traded On | Cost |
|
|
868
|
+
|------|-------|--------|------------|----------|
|
|
869
|
+
| T001 | 7.7 | 100 | 2016-11-01 | 770.0 |
|
|
870
|
+
| T002 | 7.75 | 200 | 2016-11-01 | 1550.0 |
|
|
871
|
+
| T003 | 7.5 | 800 | 2016-11-01 | 6000.0 |
|
|
872
|
+
| T003 | 7.5 | 800 | 2016-11-01 | 6000.0 |
|
|
873
|
+
|------|-------|--------|------------|----------|
|
|
874
|
+
| T004 | 7.55 | 6811 | 2016-11-01 | 51423.05 |
|
|
875
|
+
| T005 | 7.5 | 4000 | 2016-11-01 | 30000.0 |
|
|
876
|
+
| T006 | 7.6 | 1000 | 2016-11-01 | 7600.0 |
|
|
877
|
+
| T006 | 7.6 | 1000 | 2016-11-01 | 7600.0 |
|
|
878
|
+
| T007 | 7.65 | 200 | 2016-11-01 | 1530.0 |
|
|
879
|
+
| T008 | 7.65 | 2771 | 2016-11-01 | 21198.15 |
|
|
880
|
+
| T009 | 7.6 | 9550 | 2016-11-01 | 72580.0 |
|
|
881
|
+
|------|-------|--------|------------|----------|
|
|
882
|
+
| T010 | 7.55 | 3175 | 2016-11-01 | 23971.25 |
|
|
883
|
+
| T011 | 7.425 | 100 | 2016-11-02 | 742.5 |
|
|
884
|
+
| T012 | 7.55 | 4700 | 2016-11-02 | 35485.0 |
|
|
885
|
+
| T012 | 7.55 | 4700 | 2016-11-02 | 35485.0 |
|
|
886
|
+
| T013 | 7.35 | 53100 | 2016-11-02 | 390285.0 |
|
|
887
|
+
|------|-------|--------|------------|----------|
|
|
888
|
+
| T014 | 7.45 | 5847 | 2016-11-02 | 43560.15 |
|
|
889
|
+
| T015 | 7.75 | 500 | 2016-11-02 | 3875.0 |
|
|
890
|
+
| T016 | 8.25 | 100 | 2016-11-02 | 825.0 |
|
|
891
|
+
|
|
892
|
+
The parameter ’`traded_on: :date`’ caused the `:date` column of the input table
|
|
893
|
+
to be renamed ’`:traded_on`, and the parameter `cost: 'price * shares'` created
|
|
894
|
+
a new column, `:cost`, as the product of values in the `:price` and `:shares`
|
|
895
|
+
columns.
|
|
896
|
+
|
|
897
|
+
The order of the columns in the result tables is the same as the order of the
|
|
898
|
+
parameters to the `select` method. So, you can re-order the columns with a
|
|
899
|
+
second, chained call to `select`:
|
|
900
|
+
|
|
901
|
+
tab1.select(:ref, :price, :shares, traded_on: :date, cost: 'price * shares') \
|
|
902
|
+
.select(:ref, :traded_on, :price, :shares, :cost) \
|
|
903
|
+
.to_aoa
|
|
904
|
+
|
|
905
|
+
| Ref | Traded On | Price | Shares | Cost |
|
|
906
|
+
|------|------------|-------|--------|----------|
|
|
907
|
+
| T001 | 2016-11-01 | 7.7 | 100 | 770.0 |
|
|
908
|
+
| T002 | 2016-11-01 | 7.75 | 200 | 1550.0 |
|
|
909
|
+
| T003 | 2016-11-01 | 7.5 | 800 | 6000.0 |
|
|
910
|
+
| T003 | 2016-11-01 | 7.5 | 800 | 6000.0 |
|
|
911
|
+
|------|------------|-------|--------|----------|
|
|
912
|
+
| T004 | 2016-11-01 | 7.55 | 6811 | 51423.05 |
|
|
913
|
+
| T005 | 2016-11-01 | 7.5 | 4000 | 30000.0 |
|
|
914
|
+
| T006 | 2016-11-01 | 7.6 | 1000 | 7600.0 |
|
|
915
|
+
| T006 | 2016-11-01 | 7.6 | 1000 | 7600.0 |
|
|
916
|
+
| T007 | 2016-11-01 | 7.65 | 200 | 1530.0 |
|
|
917
|
+
| T008 | 2016-11-01 | 7.65 | 2771 | 21198.15 |
|
|
918
|
+
| T009 | 2016-11-01 | 7.6 | 9550 | 72580.0 |
|
|
919
|
+
|------|------------|-------|--------|----------|
|
|
920
|
+
| T010 | 2016-11-01 | 7.55 | 3175 | 23971.25 |
|
|
921
|
+
| T011 | 2016-11-02 | 7.425 | 100 | 742.5 |
|
|
922
|
+
| T012 | 2016-11-02 | 7.55 | 4700 | 35485.0 |
|
|
923
|
+
| T012 | 2016-11-02 | 7.55 | 4700 | 35485.0 |
|
|
924
|
+
| T013 | 2016-11-02 | 7.35 | 53100 | 390285.0 |
|
|
925
|
+
|------|------------|-------|--------|----------|
|
|
926
|
+
| T014 | 2016-11-02 | 7.45 | 5847 | 43560.15 |
|
|
927
|
+
| T015 | 2016-11-02 | 7.75 | 500 | 3875.0 |
|
|
928
|
+
| T016 | 2016-11-02 | 8.25 | 100 | 825.0 |
|
|
929
|
+
|
|
930
|
+
3. Custom Instance Variables and Hooks
|
|
931
|
+
|
|
932
|
+
As the above examples demonstrate, the instance variables `@row` and `@group`
|
|
933
|
+
are available when evaluating expressions that add new columns. You can also set
|
|
934
|
+
up your own instance variables as well for keeping track of things that cross
|
|
935
|
+
row boundaries, such as running sums.
|
|
936
|
+
|
|
937
|
+
To declare instance variables, you can use the `ivars:` hash parameter to
|
|
938
|
+
`select`. Each key of the hash becomes an instance variable and each value
|
|
939
|
+
becomes its initial value before any rows are evaluated.
|
|
940
|
+
|
|
941
|
+
In addition, you can provide `before_hook:` and `after_hook:` parameters to
|
|
942
|
+
`select` as strings that are evaluated as ruby expressions before and after each
|
|
943
|
+
row is processed. You can use these to update instance variables. The values set
|
|
944
|
+
in the `before_hook:` can be used in expressions for adding new columns by
|
|
945
|
+
referencing them with the ’@’ prefix.
|
|
946
|
+
|
|
947
|
+
For example, suppose we wanted to not only add a cost column, but a column that
|
|
948
|
+
shows the cumulative cost after each transaction in our example table. The
|
|
949
|
+
following example uses the `ivars:` and `before_hook:` parameters to keep track
|
|
950
|
+
of the running cost of shares, then formats the table.
|
|
951
|
+
|
|
952
|
+
tab = tab1.select(:ref, :price, :shares, traded_on: :date, \
|
|
953
|
+
cost: 'price * shares', cumulative: '@total_cost', \
|
|
954
|
+
ivars: { total_cost: 0 }, \
|
|
955
|
+
before_hook: '@total_cost += price * shares')
|
|
956
|
+
FatTable.to_aoa(tab) do |f|
|
|
957
|
+
f.format(price: '0.4', shares: '0.0,', cost: '0.2,', cumulative: '0.2,')
|
|
958
|
+
end
|
|
959
|
+
|
|
960
|
+
| Ref | Price | Shares | Traded On | Cost | Cumulative |
|
|
961
|
+
|------|--------|--------|------------|------------|------------|
|
|
962
|
+
| T001 | 7.7000 | 100 | 2016-11-01 | 770.00 | 770.00 |
|
|
963
|
+
| T002 | 7.7500 | 200 | 2016-11-01 | 1,550.00 | 2,320.00 |
|
|
964
|
+
| T003 | 7.5000 | 800 | 2016-11-01 | 6,000.00 | 8,320.00 |
|
|
965
|
+
| T003 | 7.5000 | 800 | 2016-11-01 | 6,000.00 | 14,320.00 |
|
|
966
|
+
|------|--------|--------|------------|------------|------------|
|
|
967
|
+
| T004 | 7.5500 | 6,811 | 2016-11-01 | 51,423.05 | 65,743.05 |
|
|
968
|
+
| T005 | 7.5000 | 4,000 | 2016-11-01 | 30,000.00 | 95,743.05 |
|
|
969
|
+
| T006 | 7.6000 | 1,000 | 2016-11-01 | 7,600.00 | 103,343.05 |
|
|
970
|
+
| T006 | 7.6000 | 1,000 | 2016-11-01 | 7,600.00 | 110,943.05 |
|
|
971
|
+
| T007 | 7.6500 | 200 | 2016-11-01 | 1,530.00 | 112,473.05 |
|
|
972
|
+
| T008 | 7.6500 | 2,771 | 2016-11-01 | 21,198.15 | 133,671.20 |
|
|
973
|
+
| T009 | 7.6000 | 9,550 | 2016-11-01 | 72,580.00 | 206,251.20 |
|
|
974
|
+
|------|--------|--------|------------|------------|------------|
|
|
975
|
+
| T010 | 7.5500 | 3,175 | 2016-11-01 | 23,971.25 | 230,222.45 |
|
|
976
|
+
| T011 | 7.4250 | 100 | 2016-11-02 | 742.50 | 230,964.95 |
|
|
977
|
+
| T012 | 7.5500 | 4,700 | 2016-11-02 | 35,485.00 | 266,449.95 |
|
|
978
|
+
| T012 | 7.5500 | 4,700 | 2016-11-02 | 35,485.00 | 301,934.95 |
|
|
979
|
+
| T013 | 7.3500 | 53,100 | 2016-11-02 | 390,285.00 | 692,219.95 |
|
|
980
|
+
|------|--------|--------|------------|------------|------------|
|
|
981
|
+
| T014 | 7.4500 | 5,847 | 2016-11-02 | 43,560.15 | 735,780.10 |
|
|
982
|
+
| T015 | 7.7500 | 500 | 2016-11-02 | 3,875.00 | 739,655.10 |
|
|
983
|
+
| T016 | 8.2500 | 100 | 2016-11-02 | 825.00 | 740,480.10 |
|
|
984
|
+
|
|
985
|
+
4. Argument Order and Boundaries
|
|
986
|
+
|
|
987
|
+
Notice that `select` can take any number of arguments but all the symbol
|
|
988
|
+
arguments must come first followed by all the hash-like keyword arguments,
|
|
989
|
+
including the special arguments for instance variables and hooks.
|
|
990
|
+
|
|
991
|
+
As the example illustrates, `.select` transmits any group boundaries in its
|
|
992
|
+
input table to the result table.
|
|
993
|
+
|
|
994
|
+
|
|
995
|
+
<a id="orge185ad7"></a>
|
|
996
|
+
|
|
997
|
+
### Where
|
|
998
|
+
|
|
999
|
+
You can filter the rows of the result table with the `.where` method. It takes a
|
|
1000
|
+
single string expression as an argument which is evaluated in a manner similar
|
|
1001
|
+
to `.select` in which the value of the cells in each column are available as
|
|
1002
|
+
local variables and the instance variables `@row` and `@group` are available for
|
|
1003
|
+
testing. The expression is evaluated for each row, and if the expression
|
|
1004
|
+
evaluates to a truthy value, the row is included in the output, otherwise it is
|
|
1005
|
+
not. The `.where` method obliterates any group boundaries in the input, so the
|
|
1006
|
+
output table has only a single group.
|
|
1007
|
+
|
|
1008
|
+
Here we select only those even-numbered rows where either of the two boolean
|
|
1009
|
+
fields is true:
|
|
1010
|
+
|
|
1011
|
+
tab1.where('@row.even? && (g10 || qp10)') \
|
|
1012
|
+
.to_aoa
|
|
1013
|
+
|
|
1014
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1015
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1016
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1017
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1018
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1019
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1020
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1021
|
+
|
|
1022
|
+
|
|
1023
|
+
<a id="org57f51d1"></a>
|
|
1024
|
+
|
|
1025
|
+
### Order\_by
|
|
1026
|
+
|
|
1027
|
+
You can sort a table on any number of columns with `order_by`. The `order_by`
|
|
1028
|
+
method takes any number of symbol arguments for the columns to sort on. If you
|
|
1029
|
+
specify more than one column, the sort is performed on the first column, then
|
|
1030
|
+
all columns that are equal with respect to the first column are sorted by the
|
|
1031
|
+
second column, and so on. All columns of the input table are included in the
|
|
1032
|
+
output.
|
|
1033
|
+
|
|
1034
|
+
Let’s sort our table first by `:code`, then by `:date`.
|
|
1035
|
+
|
|
1036
|
+
tab1.order_by(:code, :date) \
|
|
1037
|
+
.to_aoa
|
|
1038
|
+
|
|
1039
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1040
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1041
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1042
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1043
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1044
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1045
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1046
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1047
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1048
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1049
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1050
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1051
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1052
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1053
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1054
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1055
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1056
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1057
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1058
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1059
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1060
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1061
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1062
|
+
|
|
1063
|
+
The interesting thing about `order_by` is that, while it ignores groups in its
|
|
1064
|
+
input, it adds group boundaries in the output table at those rows where the sort
|
|
1065
|
+
keys change. Thus, in each group, `:code` and `:date` are the same, and when
|
|
1066
|
+
either changes, `order_by` inserts a group boundary.
|
|
1067
|
+
|
|
1068
|
+
|
|
1069
|
+
<a id="org1ee0a85"></a>
|
|
1070
|
+
|
|
1071
|
+
### Group\_by
|
|
1072
|
+
|
|
1073
|
+
Like `order_by`, `group_by` takes a set of parameters of column header symbols,
|
|
1074
|
+
the “grouping parameters”, by which to sort the table into a set of groups that
|
|
1075
|
+
are equal with respect to values in those columns. In addition, those parameters
|
|
1076
|
+
can be followed by a series of hash-like parameters, the “aggregating
|
|
1077
|
+
parameters”, that indicate how any of the remaining, non-group columns are to be
|
|
1078
|
+
aggregated into a single value. The output table has one row for each group for
|
|
1079
|
+
which the grouping parameters are equal containing those columns and an
|
|
1080
|
+
aggregate column for each of the aggregating parameters.
|
|
1081
|
+
|
|
1082
|
+
For example, let’s summarize the `trades` table by `:code` and `:price` again,
|
|
1083
|
+
and determine total shares, average price, and a few other features of each
|
|
1084
|
+
group:
|
|
1085
|
+
|
|
1086
|
+
tab1.group_by(:code, :date, price: :avg,
|
|
1087
|
+
shares: :sum, lp: :sum, qp: :sum,
|
|
1088
|
+
qp10: :all?) \
|
|
1089
|
+
.to_aoa { |f| f.format(avg_price: '0.5R') }
|
|
1090
|
+
|
|
1091
|
+
| Code | Date | Avg Price | Sum Shares | Sum Lp | Sum Qp | All QP10 |
|
|
1092
|
+
|------|------------|-----------|------------|--------|--------|----------|
|
|
1093
|
+
| P | 2016-11-01 | 7.60714 | 17396 | 2473 | 14923 | F |
|
|
1094
|
+
| P | 2016-11-02 | 7.61786 | 69047 | 9945 | 59102 | F |
|
|
1095
|
+
| S | 2016-11-01 | 7.58000 | 13011 | 1852 | 11159 | F |
|
|
1096
|
+
|
|
1097
|
+
After the grouping column parameters, `:code` and `:date`, there are several
|
|
1098
|
+
hash-like “aggregating” parameters where the key is the column to aggregate and
|
|
1099
|
+
the value is a symbol for one of several aggregating methods that
|
|
1100
|
+
`FatTable::Column` objects understand. For example, the `:avg` method is applied
|
|
1101
|
+
to the :price column so that the output shows the average price in each group.
|
|
1102
|
+
The `:shares`, `:lp`, and `:qp` columns are summed, and the `:any?` aggregate is
|
|
1103
|
+
applied to one of the boolean fields, that is, it is `true` if any of the values
|
|
1104
|
+
in that column are `true`. The column names in the output of the aggregated
|
|
1105
|
+
columns have the name of the aggregating method pre-pended to the column name.
|
|
1106
|
+
|
|
1107
|
+
Here is a list of all the aggregate methods available. If the description
|
|
1108
|
+
restricts the aggregate to particular column types, applying it to other types
|
|
1109
|
+
will raise an exception.
|
|
1110
|
+
|
|
1111
|
+
- **`first`:** the first non-nil item in the column,
|
|
1112
|
+
- **`last`:** the last non-nil item in the column,
|
|
1113
|
+
- **`rng`:** form a string of the form `"#{first}..#{last}"` to show the range of
|
|
1114
|
+
values in the column,
|
|
1115
|
+
- **`sum`:** for `Numeric` and `String` columns, apply ’+’ to all the non-nil
|
|
1116
|
+
values,
|
|
1117
|
+
- **`count`:** the number of non-nil values in the column,
|
|
1118
|
+
- **`min`:** for `Numeric`, `String`, and `DateTime` columns, return the smallest
|
|
1119
|
+
non-nil value in the column,
|
|
1120
|
+
- **`max`:** for `Numeric`, `String`, and `DateTime` columns, return the largest
|
|
1121
|
+
non-nil value in the column,
|
|
1122
|
+
- **`avg`:** for `Numeric` and `DateTime` columns, return the arithmetic mean of
|
|
1123
|
+
the non-nil values in the column; with respect to `Date` or `DateTime`
|
|
1124
|
+
objects, each is converted to a numeric Julian date, the average is
|
|
1125
|
+
calculated, and the result converted back to a `Date` or `DateTime` object,
|
|
1126
|
+
- **`var`:** for `Numeric` and `DateTime` columns, compute the sample variance of
|
|
1127
|
+
the non-nil values in the column, dates are converted to Julian date
|
|
1128
|
+
numbers as for the `:avg` aggregate,
|
|
1129
|
+
- **`pvar`:** for `Numeric` and `DateTime` columns, compute the population
|
|
1130
|
+
variance of the non-nil values in the column, dates are converted to Julian
|
|
1131
|
+
date numbers as for the `:avg` aggregate,
|
|
1132
|
+
- **`dev`:** for `Numeric` and `DateTime` columns, compute the sample standard
|
|
1133
|
+
deviation of the non-nil values in the column, dates are converted to
|
|
1134
|
+
Julian date numbers as for the `:avg` aggregate,
|
|
1135
|
+
- **`pdev`:** for `Numeric` and `DateTime` columns, compute the population
|
|
1136
|
+
standard deviation of the non-nil values in the column, dates are converted
|
|
1137
|
+
to numbers as for the `:avg` aggregate,
|
|
1138
|
+
- **`all?`:** for `Boolean` columns only, return true if all of the non-nil values
|
|
1139
|
+
in the column are true,
|
|
1140
|
+
- **`any?`:** for `Boolean` columns only, return true if any non-nil value in the
|
|
1141
|
+
column is true,
|
|
1142
|
+
- **`none?`:** for `Boolean` columns only, return true if no non-nil value in the
|
|
1143
|
+
column is true,
|
|
1144
|
+
- **`one?`:** for `Boolean` columns only, return true if exactly one non-nil value
|
|
1145
|
+
in the column is true,
|
|
1146
|
+
|
|
1147
|
+
Perhaps surprisingly, the `group_by` method ignores any groups in its input and
|
|
1148
|
+
results in no group boundaries in the output since each group formed by the
|
|
1149
|
+
implicit `order_by` on the grouping columns is collapsed into a single row.
|
|
1150
|
+
|
|
1151
|
+
|
|
1152
|
+
<a id="org6432f26"></a>
|
|
1153
|
+
|
|
1154
|
+
### Join
|
|
1155
|
+
|
|
1156
|
+
1. Join Types
|
|
1157
|
+
|
|
1158
|
+
So far, all the operations have operated on a single table. `FatTable` provides
|
|
1159
|
+
several `join` methods for combining two tables, each of which takes as
|
|
1160
|
+
parameters (1) a second table and (2) except in the case of `cross_join`, zero
|
|
1161
|
+
or more “join expressions”. In the descriptions below, `T1` is the table on
|
|
1162
|
+
which the method is called, `T2` is the table supplied as the first parameter
|
|
1163
|
+
`other`, and `R1` and `R2` are rows in their respective tables being considered
|
|
1164
|
+
for inclusion in the joined output table.
|
|
1165
|
+
|
|
1166
|
+
- **`join(other, *jexps)`:** Performs an “inner join” on the tables. For each row
|
|
1167
|
+
`R1` of `T1`, the joined table has a row for each row in `T2` that
|
|
1168
|
+
satisfies the join condition with `R1`.
|
|
1169
|
+
|
|
1170
|
+
- **`left_join(other, *jexps)`:** First, an inner join is performed. Then, for
|
|
1171
|
+
each row in `T1` that does not satisfy the join condition with any row in
|
|
1172
|
+
`T2`, a joined row is added with null values in columns of `T2`. Thus, the
|
|
1173
|
+
joined table always has at least one row for each row in `T1`.
|
|
1174
|
+
|
|
1175
|
+
- **`right_join(other, *jexps)`:** First, an inner join is performed. Then, for
|
|
1176
|
+
each row in `T2` that does not satisfy the join condition with any row in
|
|
1177
|
+
`T1`, a joined row is added with null values in columns of `T1`. This is
|
|
1178
|
+
the converse of a left join: the result table will always have a row for
|
|
1179
|
+
each row in `T2`.
|
|
1180
|
+
|
|
1181
|
+
- **`full_join(other, *jexps)`:** First, an inner join is performed. Then, for
|
|
1182
|
+
each row in `T1` that does not satisfy the join condition with any row in
|
|
1183
|
+
`T2`, a joined row is added with null values in columns of `T2`. Also, for
|
|
1184
|
+
each row of `T2` that does not satisfy the join condition with any row in
|
|
1185
|
+
`T1`, a joined row with null values in the columns of `T1` is added.
|
|
1186
|
+
|
|
1187
|
+
- **`cross_join(other)`:** For every possible combination of rows from `T1` and
|
|
1188
|
+
`T2` (i.e., a Cartesian product), the joined table will contain a row
|
|
1189
|
+
consisting of all columns in `T1` followed by all columns in `T2`. If the
|
|
1190
|
+
tables have `N` and `M` rows respectively, the joined table will have `N *
|
|
1191
|
+
M` rows.
|
|
1192
|
+
|
|
1193
|
+
2. Join Expressions
|
|
1194
|
+
|
|
1195
|
+
For each of the join types, if no join expressions are given, the tables will be
|
|
1196
|
+
joined on columns having the same column header in both tables, and the join
|
|
1197
|
+
condition is satisfied when all the values in those columns are equal. If the
|
|
1198
|
+
join type is an inner join, this is a so-called “natural” join.
|
|
1199
|
+
|
|
1200
|
+
If the join expressions are one or more symbols, the join condition requires
|
|
1201
|
+
that the values of both tables are equal for all columns named by the symbols. A
|
|
1202
|
+
column that appears in both tables can be given without modification and will be
|
|
1203
|
+
assumed to require equality on that column. If an unmodified symbol is not a
|
|
1204
|
+
name that appears in both tables, an exception will be raised. Column names that
|
|
1205
|
+
are unique to the first table must have a `_a` appended to the column name and
|
|
1206
|
+
column names that are unique to the other table must have a `_b` appended to the
|
|
1207
|
+
column name. These disambiguated column names must come in pairs, one for the
|
|
1208
|
+
first table and one for the second, and they will imply a join condition that
|
|
1209
|
+
the columns must be equal on those columns. Several such symbol expressions will
|
|
1210
|
+
require that all such implied pairs are equal in order for the join condition to
|
|
1211
|
+
be met.
|
|
1212
|
+
|
|
1213
|
+
Finally, a join expression can be a string that contains an arbitrary ruby
|
|
1214
|
+
expression that will be evaluated for truthiness. Within the string, *all*
|
|
1215
|
+
column names must be disambiguated with the `_a` or `_b` modifiers whether they
|
|
1216
|
+
are common to both tables or not. As with `select` and `where` methods, the
|
|
1217
|
+
names of the columns in both tables (albeit disambiguated) are available as
|
|
1218
|
+
local variables within the expression, but the instance variables `@row` and
|
|
1219
|
+
`@group` are not.
|
|
1220
|
+
|
|
1221
|
+
3. Join Examples
|
|
1222
|
+
|
|
1223
|
+
The following examples are taken from the [Postgresql tutorial](https://www.tutorialspoint.com/postgresql/postgresql_using_joins.htm), with some slight
|
|
1224
|
+
modifications. The examples will use the following two tables, which are also
|
|
1225
|
+
available in `ft_console` as `@tab_a` and `@tab_b`:
|
|
1226
|
+
|
|
1227
|
+
require 'fat_table'
|
|
1228
|
+
|
|
1229
|
+
tab_a_str = <<-EOS
|
|
1230
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
1231
|
+
|----|-------|-----|------------|--------|------------|
|
|
1232
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 |
|
|
1233
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 |
|
|
1234
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 |
|
|
1235
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 |
|
|
1236
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 |
|
|
1237
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 |
|
|
1238
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 |
|
|
1239
|
+
| 10 | James | 45 | Texas | 5000 | |
|
|
1240
|
+
EOS
|
|
1241
|
+
|
|
1242
|
+
tab_b_str = <<-EOS
|
|
1243
|
+
| Id | Dept | Emp Id |
|
|
1244
|
+
|----|-------------|--------|
|
|
1245
|
+
| 1 | IT Billing | 1 |
|
|
1246
|
+
| 2 | Engineering | 2 |
|
|
1247
|
+
| 3 | Finance | 7 |
|
|
1248
|
+
EOS
|
|
1249
|
+
|
|
1250
|
+
tab_a = FatTable.from_org_string(tab_a_str)
|
|
1251
|
+
tab_b = FatTable.from_org_string(tab_b_str)
|
|
1252
|
+
|
|
1253
|
+
1. Inner Joins
|
|
1254
|
+
|
|
1255
|
+
With no join expression arguments, the tables are joined when their sole common
|
|
1256
|
+
field, `:id`, is equal in both tables. The result is the natural join of the
|
|
1257
|
+
two tables.
|
|
1258
|
+
|
|
1259
|
+
tab_a.join(tab_b).to_aoa
|
|
1260
|
+
|
|
1261
|
+
| Id | Name | Age | Address | Salary | Join Date | Dept | Emp Id |
|
|
1262
|
+
|----|-------|-----|------------|--------|------------|-------------|--------|
|
|
1263
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | IT Billing | 1 |
|
|
1264
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | Finance | 7 |
|
|
1265
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | Engineering | 2 |
|
|
1266
|
+
|
|
1267
|
+
But the natural join joined employee IDs in the first table and department IDs
|
|
1268
|
+
in the second table. To correct this, we need to explicitly state the columns we
|
|
1269
|
+
want to join on in each table by disambiguating them with `_a` and `_b`
|
|
1270
|
+
suffixes:
|
|
1271
|
+
|
|
1272
|
+
tab_a.join(tab_b, :id_a, :emp_id_b).to_aoa
|
|
1273
|
+
|
|
1274
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept |
|
|
1275
|
+
|----|-------|-----|------------|--------|------------|------|-------------|
|
|
1276
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing |
|
|
1277
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering |
|
|
1278
|
+
|
|
1279
|
+
Instead of using the disambiguated column names as symbols, we could also use a
|
|
1280
|
+
string containing a ruby expression. Within the expression, the column names
|
|
1281
|
+
should be treated as local variables:
|
|
1282
|
+
|
|
1283
|
+
tab_a.join(tab_b, 'id_a == emp_id_b').to_aoa
|
|
1284
|
+
|
|
1285
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept | Emp Id |
|
|
1286
|
+
|----|-------|-----|------------|--------|------------|------|-------------|--------|
|
|
1287
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing | 1 |
|
|
1288
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering | 2 |
|
|
1289
|
+
|
|
1290
|
+
2. Left and Right Joins
|
|
1291
|
+
|
|
1292
|
+
In left join, all the rows of `tab_a` are included in the output, augmented by
|
|
1293
|
+
the matching columns of `tab_b` and augmented with nils where there is no match:
|
|
1294
|
+
|
|
1295
|
+
tab_a.left_join(tab_b, 'id_a == emp_id_b').to_aoa
|
|
1296
|
+
|
|
1297
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept | Emp Id |
|
|
1298
|
+
|----|-------|-----|------------|--------|------------|------|-------------|--------|
|
|
1299
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing | 1 |
|
|
1300
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | | | |
|
|
1301
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 | | | |
|
|
1302
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 | | | |
|
|
1303
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering | 2 |
|
|
1304
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 | | | |
|
|
1305
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 | | | |
|
|
1306
|
+
| 10 | James | 45 | Texas | 5000 | | | | |
|
|
1307
|
+
|
|
1308
|
+
In a right join, all the rows of `tab_b` are included in the output, augmented
|
|
1309
|
+
by the matching columns of `tab_a` and augmented with nils where there is no
|
|
1310
|
+
match:
|
|
1311
|
+
|
|
1312
|
+
tab_a.right_join(tab_b, 'id_a == emp_id_b').to_aoa
|
|
1313
|
+
|
|
1314
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept | Emp Id |
|
|
1315
|
+
|----|-------|-----|------------|--------|------------|------|-------------|--------|
|
|
1316
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing | 1 |
|
|
1317
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering | 2 |
|
|
1318
|
+
| | | | | | | 3 | Finance | 7 |
|
|
1319
|
+
|
|
1320
|
+
3. Full Join
|
|
1321
|
+
|
|
1322
|
+
A full join combines the effects of a left join and a right join. All the rows
|
|
1323
|
+
from both tables are included in the output augmented by columns of the other
|
|
1324
|
+
table where the join expression is satisfied and augmented with nils otherwise.
|
|
1325
|
+
|
|
1326
|
+
tab_a.full_join(tab_b, 'id_a == emp_id_b').to_aoa
|
|
1327
|
+
|
|
1328
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept | Emp Id |
|
|
1329
|
+
|----|-------|-----|------------|--------|------------|------|-------------|--------|
|
|
1330
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing | 1 |
|
|
1331
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | | | |
|
|
1332
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 | | | |
|
|
1333
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 | | | |
|
|
1334
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering | 2 |
|
|
1335
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 | | | |
|
|
1336
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 | | | |
|
|
1337
|
+
| 10 | James | 45 | Texas | 5000 | | | | |
|
|
1338
|
+
| | | | | | | 3 | Finance | 7 |
|
|
1339
|
+
|
|
1340
|
+
4. Cross Join
|
|
1341
|
+
|
|
1342
|
+
Finally, a cross join outputs every row of `tab_a` augmented with every row of
|
|
1343
|
+
`tab_b`, in other words, the Cartesian product of the two tables. If `tab_a` has
|
|
1344
|
+
`N` rows and `tab_b` has `M` rows, the output table will have `N * M` rows.
|
|
1345
|
+
|
|
1346
|
+
tab_a.cross_join(tab_b).to_aoa
|
|
1347
|
+
|
|
1348
|
+
| Id | Name | Age | Address | Salary | Join Date | Id B | Dept | Emp Id |
|
|
1349
|
+
|----|-------|-----|------------|--------|------------|------|-------------|--------|
|
|
1350
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 1 | IT Billing | 1 |
|
|
1351
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 2 | Engineering | 2 |
|
|
1352
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 | 3 | Finance | 7 |
|
|
1353
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | 1 | IT Billing | 1 |
|
|
1354
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | 2 | Engineering | 2 |
|
|
1355
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 | 3 | Finance | 7 |
|
|
1356
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 | 1 | IT Billing | 1 |
|
|
1357
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 | 2 | Engineering | 2 |
|
|
1358
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 | 3 | Finance | 7 |
|
|
1359
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 | 1 | IT Billing | 1 |
|
|
1360
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 | 2 | Engineering | 2 |
|
|
1361
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 | 3 | Finance | 7 |
|
|
1362
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 1 | IT Billing | 1 |
|
|
1363
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 2 | Engineering | 2 |
|
|
1364
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 | 3 | Finance | 7 |
|
|
1365
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 | 1 | IT Billing | 1 |
|
|
1366
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 | 2 | Engineering | 2 |
|
|
1367
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 | 3 | Finance | 7 |
|
|
1368
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 | 1 | IT Billing | 1 |
|
|
1369
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 | 2 | Engineering | 2 |
|
|
1370
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 | 3 | Finance | 7 |
|
|
1371
|
+
| 10 | James | 45 | Texas | 5000 | | 1 | IT Billing | 1 |
|
|
1372
|
+
| 10 | James | 45 | Texas | 5000 | | 2 | Engineering | 2 |
|
|
1373
|
+
| 10 | James | 45 | Texas | 5000 | | 3 | Finance | 7 |
|
|
1374
|
+
|
|
1375
|
+
|
|
1376
|
+
<a id="org7d2857d"></a>
|
|
1377
|
+
|
|
1378
|
+
### Set Operations
|
|
1379
|
+
|
|
1380
|
+
`FatTable` can perform several set operations on tables. In order for two tables
|
|
1381
|
+
to be used this way, they must have the same number of columns with the same
|
|
1382
|
+
types or an exception will be raised. We’ll call two tables that qualify for
|
|
1383
|
+
combining with set operations “set-compatible.”
|
|
1384
|
+
|
|
1385
|
+
We’ll use the following two set-compatible tables in the examples. They each
|
|
1386
|
+
have some duplicates and some group boundaries so you can see the effect of the
|
|
1387
|
+
set operations on duplicates and groups.
|
|
1388
|
+
|
|
1389
|
+
tab1.to_aoa
|
|
1390
|
+
|
|
1391
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1392
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1393
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1394
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1395
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1396
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1397
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1398
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1399
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1400
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1401
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1402
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1403
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1404
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1405
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1406
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1407
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1408
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1409
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1410
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1411
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1412
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1413
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1414
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1415
|
+
|
|
1416
|
+
tab2.to_aoa
|
|
1417
|
+
|
|
1418
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1419
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1420
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1421
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1422
|
+
| T017 | 2016-11-01 | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
1423
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1424
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1425
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1426
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1427
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1428
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1429
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1430
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1431
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1432
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1433
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1434
|
+
| T019 | 2017-01-15 | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
1435
|
+
| T020 | 2017-01-19 | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
1436
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1437
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1438
|
+
|
|
1439
|
+
1. Unions
|
|
1440
|
+
|
|
1441
|
+
Two tables that are set-compatible can be combined with the `union` or
|
|
1442
|
+
`union_all` methods so that the rows of both tables appear in the output. In the
|
|
1443
|
+
output table, the headers of the receiver table are used. You can use `select`
|
|
1444
|
+
to change or re-order the headers if you prefer. The `union` method eliminates
|
|
1445
|
+
duplicate rows in the result table, the `union_all` method does not.
|
|
1446
|
+
|
|
1447
|
+
Any group boundaries in the input tables are destroyed by `union` but are
|
|
1448
|
+
preserved by `union_all`. In addition, `union_all` (but not `union`) adds a
|
|
1449
|
+
group boundary between the rows of the two input tables.
|
|
1450
|
+
|
|
1451
|
+
tab1.union(tab2).to_aoa
|
|
1452
|
+
|
|
1453
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1454
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1455
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1456
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1457
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1458
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1459
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1460
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1461
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1462
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1463
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1464
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1465
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1466
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1467
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1468
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1469
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1470
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1471
|
+
| T017 | 2016-11-01 | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
1472
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1473
|
+
| T019 | 2017-01-15 | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
1474
|
+
| T020 | 2017-01-19 | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
1475
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1476
|
+
|
|
1477
|
+
tab1.union_all(tab2).to_aoa
|
|
1478
|
+
|
|
1479
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1480
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1481
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1482
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1483
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1484
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1485
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1486
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1487
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1488
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1489
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1490
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1491
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1492
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1493
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1494
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1495
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1496
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1497
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1498
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1499
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1500
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1501
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1502
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1503
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1504
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1505
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1506
|
+
| T017 | 2016-11-01 | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
1507
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1508
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1509
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1510
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1511
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1512
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1513
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1514
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1515
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1516
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1517
|
+
|------|------------|------|-------|-----|------|--------|-------|-------|--------|--------|
|
|
1518
|
+
| T019 | 2017-01-15 | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
1519
|
+
| T020 | 2017-01-19 | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
1520
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1521
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1522
|
+
|
|
1523
|
+
2. Intersections
|
|
1524
|
+
|
|
1525
|
+
The `intersect` method returns a table having only rows common to both tables,
|
|
1526
|
+
eliminating any duplicate rows in the result.
|
|
1527
|
+
|
|
1528
|
+
tab1.intersect(tab2).to_aoa
|
|
1529
|
+
|
|
1530
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1531
|
+
|------|------------|------|-------|-----|------|--------|-----|------|--------|--------|
|
|
1532
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1533
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1534
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1535
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1536
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1537
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1538
|
+
|
|
1539
|
+
With `intersect_all`, all the rows of the first table, including duplicates, are
|
|
1540
|
+
included in the result if they also occur in the second table. However,
|
|
1541
|
+
duplicates in the second table do not appear.
|
|
1542
|
+
|
|
1543
|
+
tab1.intersect_all(tab2).to_aoa
|
|
1544
|
+
|
|
1545
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1546
|
+
|------|------------|------|-------|-----|------|--------|-----|------|--------|--------|
|
|
1547
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1548
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1549
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1550
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1551
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1552
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1553
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1554
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1555
|
+
|
|
1556
|
+
As a result, it makes a difference which table is the receiver of the
|
|
1557
|
+
`intersect_all` method call and which is the argument. In other words, order of
|
|
1558
|
+
operation matters.
|
|
1559
|
+
|
|
1560
|
+
tab2.intersect_all(tab1).to_aoa
|
|
1561
|
+
|
|
1562
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1563
|
+
|------|------------|------|-------|-----|------|--------|-----|------|--------|--------|
|
|
1564
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1565
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1566
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1567
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1568
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1569
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1570
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1571
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1572
|
+
|
|
1573
|
+
3. Differences with Except
|
|
1574
|
+
|
|
1575
|
+
You can use the `except` method to delete from a table any rows that occur in
|
|
1576
|
+
another table, that is, compute the set difference between the tables.
|
|
1577
|
+
|
|
1578
|
+
tab1.except(tab2).to_aoa
|
|
1579
|
+
|
|
1580
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1581
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1582
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1583
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1584
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1585
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1586
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1587
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1588
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1589
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1590
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1591
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1592
|
+
|
|
1593
|
+
Like subtraction, though, the order of operands matters with set difference
|
|
1594
|
+
computed by `except`.
|
|
1595
|
+
|
|
1596
|
+
tab2.except(tab1).to_aoa
|
|
1597
|
+
|
|
1598
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1599
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1600
|
+
| T017 | 2016-11-01 | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
1601
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1602
|
+
| T019 | 2017-01-15 | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
1603
|
+
| T020 | 2017-01-19 | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
1604
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1605
|
+
|
|
1606
|
+
As with `intersect_all`, `except_all` includes any duplicates in the first,
|
|
1607
|
+
receiver table, but not those in the second, argument table.
|
|
1608
|
+
|
|
1609
|
+
tab1.except_all(tab2).to_aoa
|
|
1610
|
+
|
|
1611
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1612
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1613
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1614
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1615
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1616
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1617
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1618
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1619
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1620
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1621
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1622
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1623
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1624
|
+
|
|
1625
|
+
And, of course, the order of operands matters here as well.
|
|
1626
|
+
|
|
1627
|
+
tab2.except_all(tab1).to_aoa
|
|
1628
|
+
|
|
1629
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1630
|
+
|------|------------|------|-------|-----|------|--------|-------|------|--------|--------|
|
|
1631
|
+
| T017 | 2016-11-01 | P | 8.3 | F | T | 1801 | 1201 | 600 | 0.2453 | 0.1924 |
|
|
1632
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1633
|
+
| T018 | 2016-11-01 | S | 7.152 | T | F | 2516 | 2400 | 116 | 0.2453 | 0.1924 |
|
|
1634
|
+
| T019 | 2017-01-15 | S | 8.75 | T | F | 300 | 175 | 125 | 0.2453 | 0.1924 |
|
|
1635
|
+
| T020 | 2017-01-19 | S | 8.25 | F | T | 700 | 615 | 85 | 0.2453 | 0.1924 |
|
|
1636
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1637
|
+
| T021 | 2017-01-23 | P | 7.16 | T | T | 12100 | 11050 | 1050 | 0.2453 | 0.1924 |
|
|
1638
|
+
|
|
1639
|
+
|
|
1640
|
+
<a id="org073a8b5"></a>
|
|
1641
|
+
|
|
1642
|
+
### Uniq (aka Distinct)
|
|
1643
|
+
|
|
1644
|
+
The `uniq` method takes no arguments and simply removes any duplicate rows from
|
|
1645
|
+
the input table. The `distinct` method is an alias for `uniq`. Any groups in
|
|
1646
|
+
the input table are lost.
|
|
1647
|
+
|
|
1648
|
+
tab1.uniq.to_aoa
|
|
1649
|
+
|
|
1650
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1651
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1652
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1653
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1654
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1655
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1656
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1657
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1658
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1659
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1660
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1661
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1662
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1663
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1664
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1665
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1666
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1667
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1668
|
+
|
|
1669
|
+
|
|
1670
|
+
<a id="orgd147303"></a>
|
|
1671
|
+
|
|
1672
|
+
### Remove groups with degroup!
|
|
1673
|
+
|
|
1674
|
+
Finally, it is sometimes helpful to remove any group boundaries from a table.
|
|
1675
|
+
You can do this with `.degroup!`, which is the only operation that mutates its
|
|
1676
|
+
receiver table by removing its groups.
|
|
1677
|
+
|
|
1678
|
+
tab1.degroup!.to_aoa
|
|
1679
|
+
|
|
1680
|
+
| Ref | Date | Code | Price | G10 | QP10 | Shares | Lp | Qp | Iplp | Ipqp |
|
|
1681
|
+
|------|------------|------|-------|-----|------|--------|------|-------|--------|--------|
|
|
1682
|
+
| T001 | 2016-11-01 | P | 7.7 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1683
|
+
| T002 | 2016-11-01 | P | 7.75 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1684
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1685
|
+
| T003 | 2016-11-01 | P | 7.5 | F | T | 800 | 112 | 688 | 0.2453 | 0.1924 |
|
|
1686
|
+
| T004 | 2016-11-01 | S | 7.55 | T | F | 6811 | 966 | 5845 | 0.2453 | 0.1924 |
|
|
1687
|
+
| T005 | 2016-11-01 | S | 7.5 | F | F | 4000 | 572 | 3428 | 0.2453 | 0.1924 |
|
|
1688
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1689
|
+
| T006 | 2016-11-01 | S | 7.6 | F | T | 1000 | 143 | 857 | 0.2453 | 0.1924 |
|
|
1690
|
+
| T007 | 2016-11-01 | S | 7.65 | T | F | 200 | 28 | 172 | 0.2453 | 0.1924 |
|
|
1691
|
+
| T008 | 2016-11-01 | P | 7.65 | F | F | 2771 | 393 | 2378 | 0.2453 | 0.1924 |
|
|
1692
|
+
| T009 | 2016-11-01 | P | 7.6 | F | F | 9550 | 1363 | 8187 | 0.2453 | 0.1924 |
|
|
1693
|
+
| T010 | 2016-11-01 | P | 7.55 | F | T | 3175 | 451 | 2724 | 0.2453 | 0.1924 |
|
|
1694
|
+
| T011 | 2016-11-02 | P | 7.425 | T | F | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1695
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1696
|
+
| T012 | 2016-11-02 | P | 7.55 | F | F | 4700 | 677 | 4023 | 0.2453 | 0.1924 |
|
|
1697
|
+
| T013 | 2016-11-02 | P | 7.35 | T | T | 53100 | 7656 | 45444 | 0.2453 | 0.1924 |
|
|
1698
|
+
| T014 | 2016-11-02 | P | 7.45 | F | T | 5847 | 835 | 5012 | 0.2453 | 0.1924 |
|
|
1699
|
+
| T015 | 2016-11-02 | P | 7.75 | F | F | 500 | 72 | 428 | 0.2453 | 0.1924 |
|
|
1700
|
+
| T016 | 2016-11-02 | P | 8.25 | T | T | 100 | 14 | 86 | 0.2453 | 0.1924 |
|
|
1701
|
+
|
|
1702
|
+
|
|
1703
|
+
<a id="org9f4d633"></a>
|
|
1704
|
+
|
|
1705
|
+
## Formatting Tables
|
|
1706
|
+
|
|
1707
|
+
Besides creating and operating on tables, you may want to display the resulting
|
|
1708
|
+
table. `FatTable` seeks to provide a set of formatting directives that are the
|
|
1709
|
+
most common across many output media. It provides directives for alignment, for
|
|
1710
|
+
color, for adding currency symbols and grouping commas to numbers, for padding
|
|
1711
|
+
numbers, and for formatting dates and booleans.
|
|
1712
|
+
|
|
1713
|
+
In addition, you can add any number of footers to a table, which appear at the
|
|
1714
|
+
end of the table, and any number of group footers, which appear after each group
|
|
1715
|
+
in the table. These can be formatted independently of the table body.
|
|
1716
|
+
|
|
1717
|
+
If the target output medium does not support a formatting directive or the
|
|
1718
|
+
directive does not make sense, it is simply ignored. For example, you can output
|
|
1719
|
+
an `org-mode` table as a String, and since `org-mode` does not support colors,
|
|
1720
|
+
any color directives are ignored. Some of the output targets are not strings,
|
|
1721
|
+
but ruby data structures, and for them, things such as alignment are irrelevant.
|
|
1722
|
+
|
|
1723
|
+
|
|
1724
|
+
<a id="orgb7b2335"></a>
|
|
1725
|
+
|
|
1726
|
+
### Available Formatters
|
|
1727
|
+
|
|
1728
|
+
`FatTable` supports the following output targets for its tables:
|
|
1729
|
+
|
|
1730
|
+
- **Text:** form the table with ACSII characters,
|
|
1731
|
+
- **Org:** form the table with ASCII characters but in the form used by Emacs
|
|
1732
|
+
org-mode for constructing tables,
|
|
1733
|
+
- **Term:** form the table with ANSI terminal codes and unicode characters,
|
|
1734
|
+
possibly including colored text and cell backgrounds,
|
|
1735
|
+
- **LaTeX:** form the table as input for LaTeX’s longtable environment,
|
|
1736
|
+
- **Aoh:** output the table as a ruby data structure, building the table as an
|
|
1737
|
+
array of hashes, and
|
|
1738
|
+
- **Aoa:** output the table as a ruby data structure, building the table as an
|
|
1739
|
+
array of array,
|
|
1740
|
+
|
|
1741
|
+
These are all implemented by classes that inherit from `FatTable::Formatter`
|
|
1742
|
+
class by defining about a dozen methods that get called at various places during
|
|
1743
|
+
the construction of the output table. The idea is that more classes can be
|
|
1744
|
+
defined by adding additional classes.
|
|
1745
|
+
|
|
1746
|
+
|
|
1747
|
+
<a id="org4db9ae4"></a>
|
|
1748
|
+
|
|
1749
|
+
### Table Locations
|
|
1750
|
+
|
|
1751
|
+
In the formatting methods, the table is divided into several “locations” for
|
|
1752
|
+
which separate formatting directives may be given. These locations are
|
|
1753
|
+
identified with the following symbols:
|
|
1754
|
+
|
|
1755
|
+
- **:header:** the first row of the output table containing the headers,
|
|
1756
|
+
- **:footer:** all rows of the table’s footers,
|
|
1757
|
+
- **:gfooter:** all rows of the table’s group footers,
|
|
1758
|
+
- **:body:** all the data rows of the table, that is, those that are neither part
|
|
1759
|
+
of the header, footers, or gfooters,
|
|
1760
|
+
- **:bfirst:** the first row of the table’s body, and
|
|
1761
|
+
- **:gfirst:** the first row in each group in the table’s body.
|
|
1762
|
+
|
|
1763
|
+
|
|
1764
|
+
<a id="orgd2128a3"></a>
|
|
1765
|
+
|
|
1766
|
+
### Formatting Directives
|
|
1767
|
+
|
|
1768
|
+
The formatting methods explained in the next section all take formatting
|
|
1769
|
+
directives as strings in which letters and other characters signify what
|
|
1770
|
+
formatting applies. For example, we may apply the formatting directive `'R,$'`
|
|
1771
|
+
to numbers in a certain part of the table. Each of those characters, and in
|
|
1772
|
+
some cases a whole substring, is a single directive. They can appear in any
|
|
1773
|
+
order, so `'$R,'` and `',$R'` are equivalent.
|
|
1774
|
+
|
|
1775
|
+
Here is a list of all the formatting directives that apply to each cell type:
|
|
1776
|
+
|
|
1777
|
+
1. String
|
|
1778
|
+
|
|
1779
|
+
For a string element, the following instructions are valid. Note that these can
|
|
1780
|
+
also be applied to all the other cell types as well since they are all converted
|
|
1781
|
+
to a string in forming the output.
|
|
1782
|
+
|
|
1783
|
+
- **u:** convert the element to all lowercase,
|
|
1784
|
+
- **U:** convert the element to all uppercase,
|
|
1785
|
+
- **t:** title case the element, that is, upcase the initial letter in
|
|
1786
|
+
each word and lower case the other letters
|
|
1787
|
+
- **B ~B:** make the element bold, or turn off bold
|
|
1788
|
+
- **I ~I:** make the element italic, or turn off italic
|
|
1789
|
+
- **R:** align the element on the right of the column
|
|
1790
|
+
- **L:** align the element on the left of the column
|
|
1791
|
+
- **C:** align the element in the center of the column
|
|
1792
|
+
- **c[color]:** render the element in the given color; the color can have
|
|
1793
|
+
the form fgcolor, fgcolor.bgcolor, or .bgcolor, to set the
|
|
1794
|
+
foreground or background colors respectively, and each of those can
|
|
1795
|
+
be an ANSI or X11 color name in addition to the special color,
|
|
1796
|
+
’none’, which keeps the terminal’s default color.
|
|
1797
|
+
- **\_ ~\_:** underline the element, or turn off underline
|
|
1798
|
+
- **\* ~\*:** cause the element to blink, or turn off blink
|
|
1799
|
+
|
|
1800
|
+
For example, the directive `'tCc[red.yellow]'` would title-case the element,
|
|
1801
|
+
center it, and color it red on a yellow background. The directives that are
|
|
1802
|
+
boolean have negating forms so that, for example, if bold is turned on for all
|
|
1803
|
+
columns of a given type, it can be countermanded in formatting directives for
|
|
1804
|
+
particular columns.
|
|
1805
|
+
|
|
1806
|
+
2. Numeric
|
|
1807
|
+
|
|
1808
|
+
For a numeric element, all the instructions valid for string are available, in
|
|
1809
|
+
addition to the following:
|
|
1810
|
+
|
|
1811
|
+
- **, ~,:** insert grouping commas, or do not insert grouping commas,
|
|
1812
|
+
- **$ ~$:** format the number as currency according to the locale, or not,
|
|
1813
|
+
- **m.n:** include at least m digits before the decimal point, padding on
|
|
1814
|
+
the left with zeroes as needed, and round the number to the n
|
|
1815
|
+
decimal places and include n digits after the decimal point,
|
|
1816
|
+
padding on the right with zeroes as needed,
|
|
1817
|
+
- **H:** convert the number (assumed to be in units of seconds) to `HH:MM:SS.ss`
|
|
1818
|
+
form. So a column that is the result of subtracting two :datetime forms
|
|
1819
|
+
will result in a :numeric expressed as seconds and can be displayed in
|
|
1820
|
+
hours, minutes, and seconds with this formatting instruction.
|
|
1821
|
+
|
|
1822
|
+
For example, the directive `'R5.0c[blue]'` would right-align the numeric
|
|
1823
|
+
element, pad it on the left with zeros, and color it blue.
|
|
1824
|
+
|
|
1825
|
+
3. DateTime
|
|
1826
|
+
|
|
1827
|
+
For a `DateTime`, all the instructions valid for string are available, in
|
|
1828
|
+
addition to the following:
|
|
1829
|
+
|
|
1830
|
+
- **d[fmt]:** apply the format to a `Date` or a `DateTime` that is a whole day,
|
|
1831
|
+
that is that has no or zero hour, minute, and second components, where fmt
|
|
1832
|
+
is a valid format string for `Date#strftime`, otherwise, the datetime will
|
|
1833
|
+
be formatted as an ISO 8601 string, YYYY-MM-DD.
|
|
1834
|
+
- **D[fmt]:** apply the format to a datetime that has at least a non-zero hour
|
|
1835
|
+
component where fmt is a valid format string for Date#strftime, otherwise,
|
|
1836
|
+
the datetime will be formatted as an ISO 8601 string, YYYY-MM-DD.
|
|
1837
|
+
|
|
1838
|
+
For example, `'c[pink]d[%b %-d, %Y]C'`, would format a date element like ’Sep
|
|
1839
|
+
22, 1957’, center it, and color it pink.
|
|
1840
|
+
|
|
1841
|
+
4. Boolean
|
|
1842
|
+
|
|
1843
|
+
For a boolean cell, all the instructions valid for string are available, in
|
|
1844
|
+
addition to the following:
|
|
1845
|
+
|
|
1846
|
+
- **Y:** print true as ’`Y`’ and false as ’`N`’,
|
|
1847
|
+
- **T:** print true as ’`T`’ and false as ’`F`’,
|
|
1848
|
+
- **X:** print true as ’`X`’ and false as an empty string ’’,
|
|
1849
|
+
- **b[xxx,yyy]:** print true as the string given as `xxx` and false as the string
|
|
1850
|
+
given as `yyy`,
|
|
1851
|
+
- **c[tcolor,fcolor]:** color a true element with `tcolor` and a false element
|
|
1852
|
+
with `fcolor`. Each of the colors may be specified in the same manner as
|
|
1853
|
+
colors for strings described above.
|
|
1854
|
+
|
|
1855
|
+
For example, the directive ’`b[Yeppers,Nope]c[green.pink,red.pink]`’ would
|
|
1856
|
+
render a true boolean as ’`Yeppers`’ colored green on pink and render a false
|
|
1857
|
+
boolean as ’`Nope`’ colored red on pink. See [Yeppers](https://www.youtube.com/watch?v=oLdFFD8II8U) for additional information.
|
|
1858
|
+
|
|
1859
|
+
5. NilClass
|
|
1860
|
+
|
|
1861
|
+
By default, `nil` elements are rendered as blank cells, but you can make them
|
|
1862
|
+
visible with the following, and in that case, all the formatting instructions
|
|
1863
|
+
valid for strings are also available:
|
|
1864
|
+
|
|
1865
|
+
- **n[niltext]:** render a `nil` item with the given niltext.
|
|
1866
|
+
|
|
1867
|
+
For example, you might want to use `'n[-]Cc[purple]'` to make nils visible as a
|
|
1868
|
+
centered purple hyphen.
|
|
1869
|
+
|
|
1870
|
+
|
|
1871
|
+
<a id="org947e8a4"></a>
|
|
1872
|
+
|
|
1873
|
+
### Footers Methods
|
|
1874
|
+
|
|
1875
|
+
You can call the `footer` and `gfooter` methods on `Formatter` objects to add
|
|
1876
|
+
footers and group footers. Their signatures are:
|
|
1877
|
+
|
|
1878
|
+
- **`footer(label, *sum_cols, **agg_cols)`:** where `label` is a label to be
|
|
1879
|
+
placed in the first cell of the footer (unless that column is named as one
|
|
1880
|
+
of the `sum_cols` or `agg_cols`, in which case the label is ignored),
|
|
1881
|
+
`*sum_cols` are zero or more symbols for columns to be summed, and
|
|
1882
|
+
`**agg_cols` is zero or more hash-like parameters with a column symbol as a
|
|
1883
|
+
key and a symbol for an aggregate method as the value. This causes a
|
|
1884
|
+
table-wide header to be added at the bottom of the table applying the
|
|
1885
|
+
`:sum` aggregate to the `sum_cols` and the named aggregate method to the
|
|
1886
|
+
`agg_cols`. A table can have any number of footers attached, and they will
|
|
1887
|
+
appear at the bottom of the output table in the order they are given.
|
|
1888
|
+
|
|
1889
|
+
- **`gfooter(label, *sum_cols, **agg_cols)`:** where the parameters have the same
|
|
1890
|
+
meaning as for the `footer` method, but result in a footer for each group
|
|
1891
|
+
in the table rather than the table as a whole. These will appear in the
|
|
1892
|
+
output table just below each group.
|
|
1893
|
+
|
|
1894
|
+
There are also a number of convenience methods for adding common footers:
|
|
1895
|
+
|
|
1896
|
+
- **`sum_footer(*cols)`:** Add a footer summing the given columns with the label
|
|
1897
|
+
’Total’.
|
|
1898
|
+
- **`sum_gfooter(*cols)`:** Add a group footer summing the given columns with the
|
|
1899
|
+
label ’Group Total’.
|
|
1900
|
+
- **`avg_footer(*cols)`:** Add a footer averaging the given columns with the label
|
|
1901
|
+
’Average’.
|
|
1902
|
+
- **`avg_gfooter(*cols)`:** Add a group footer averaging the given columns with the label
|
|
1903
|
+
’Group Average’.
|
|
1904
|
+
- **`min_footer(*cols)`:** Add a footer showing the minimum for the given columns
|
|
1905
|
+
with the label ’Minimum’.
|
|
1906
|
+
- **`min_gfooter(*cols)`:** Add a group footer showing the minumum for the given
|
|
1907
|
+
columns with the label ’Group Minimum’.
|
|
1908
|
+
- **`max_footer(*cols)`:** Add a footer showing the maximum for the given columns
|
|
1909
|
+
with the label ’Maximum’.
|
|
1910
|
+
- **`max_gfooter(*cols)`:** Add a group footer showing the maximum for the given
|
|
1911
|
+
columns with the label ’Group Maximum’.
|
|
1912
|
+
|
|
1913
|
+
|
|
1914
|
+
<a id="orgcef241a"></a>
|
|
1915
|
+
|
|
1916
|
+
### Formatting Methods
|
|
1917
|
+
|
|
1918
|
+
You can call methods on `Formatter` objects to specify formatting directives
|
|
1919
|
+
for specific columns or types. There are two methods for doing so, `format_for`
|
|
1920
|
+
and `format`.
|
|
1921
|
+
|
|
1922
|
+
1. Instantiating a Formatter
|
|
1923
|
+
|
|
1924
|
+
There are several ways to invoke the formatting methods on a table. First, you
|
|
1925
|
+
can instantiate a `XXXFormatter` object and feed it a table as a parameter.
|
|
1926
|
+
There is a Formatter subclass for each target output medium, for example,
|
|
1927
|
+
`AoaFormatter` will produce a ruby array of arrays. You can then call the
|
|
1928
|
+
`output` method on the `XXXFormatter`.
|
|
1929
|
+
|
|
1930
|
+
FatTable::AoaFormatter.new(tab_a).output
|
|
1931
|
+
|
|
1932
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
1933
|
+
|----|-------|-----|------------|--------|------------|
|
|
1934
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 |
|
|
1935
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 |
|
|
1936
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 |
|
|
1937
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 |
|
|
1938
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 |
|
|
1939
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 |
|
|
1940
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 |
|
|
1941
|
+
| 10 | James | 45 | Texas | 5000 | |
|
|
1942
|
+
|
|
1943
|
+
The `XXXFormatter.new` method yields the new instance to any block given, and
|
|
1944
|
+
you can call methods on it to affect the formatting of the output:
|
|
1945
|
+
|
|
1946
|
+
FatTable::AoaFormatter.new(tab_a) do |f|
|
|
1947
|
+
f.format(numeric: '0.0,R', id: '3.0C')
|
|
1948
|
+
end.output
|
|
1949
|
+
|
|
1950
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
1951
|
+
|-----|-------|-----|------------|--------|------------|
|
|
1952
|
+
| 001 | Paul | 32 | California | 20,000 | 2001-07-13 |
|
|
1953
|
+
| 003 | Teddy | 23 | Norway | 20,000 | 2007-12-13 |
|
|
1954
|
+
| 004 | Mark | 25 | Rich-Mond | 65,000 | 2007-12-13 |
|
|
1955
|
+
| 005 | David | 27 | Texas | 85,000 | 2007-12-13 |
|
|
1956
|
+
| 002 | Allen | 25 | Texas | | 2005-07-13 |
|
|
1957
|
+
| 008 | Paul | 24 | Houston | 20,000 | 2005-07-13 |
|
|
1958
|
+
| 009 | James | 44 | Norway | 5,000 | 2005-07-13 |
|
|
1959
|
+
| 010 | James | 45 | Texas | 5,000 | |
|
|
1960
|
+
|
|
1961
|
+
2. `FatTable` module-level method calls
|
|
1962
|
+
|
|
1963
|
+
The `FatTable` module provides a set of methods of the form `to_aoa`, `to_text`,
|
|
1964
|
+
etc., to access a `Formatter` without having to create an instance yourself.
|
|
1965
|
+
Without a block, they apply the default formatting to the table and call the
|
|
1966
|
+
`.output` method automatically:
|
|
1967
|
+
|
|
1968
|
+
FatTable.to_aoa(tab_a)
|
|
1969
|
+
|
|
1970
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
1971
|
+
|----|-------|-----|------------|--------|------------|
|
|
1972
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 |
|
|
1973
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 |
|
|
1974
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 |
|
|
1975
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 |
|
|
1976
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 |
|
|
1977
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 |
|
|
1978
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 |
|
|
1979
|
+
| 10 | James | 45 | Texas | 5000 | |
|
|
1980
|
+
|
|
1981
|
+
With a block, these methods yield a `Formatter` instance on which you can call
|
|
1982
|
+
formatting and footer methods. The `.output` method is called on the `Formatter`
|
|
1983
|
+
automatically after the block:
|
|
1984
|
+
|
|
1985
|
+
FatTable.to_aoa(tab_a) do |f|
|
|
1986
|
+
f.format(numeric: '0.0,R', id: '3.0C')
|
|
1987
|
+
end
|
|
1988
|
+
|
|
1989
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
1990
|
+
|-----|-------|-----|------------|--------|------------|
|
|
1991
|
+
| 001 | Paul | 32 | California | 20,000 | 2001-07-13 |
|
|
1992
|
+
| 003 | Teddy | 23 | Norway | 20,000 | 2007-12-13 |
|
|
1993
|
+
| 004 | Mark | 25 | Rich-Mond | 65,000 | 2007-12-13 |
|
|
1994
|
+
| 005 | David | 27 | Texas | 85,000 | 2007-12-13 |
|
|
1995
|
+
| 002 | Allen | 25 | Texas | | 2005-07-13 |
|
|
1996
|
+
| 008 | Paul | 24 | Houston | 20,000 | 2005-07-13 |
|
|
1997
|
+
| 009 | James | 44 | Norway | 5,000 | 2005-07-13 |
|
|
1998
|
+
| 010 | James | 45 | Texas | 5,000 | |
|
|
1999
|
+
|
|
2000
|
+
3. Calling methods on Table objects
|
|
2001
|
+
|
|
2002
|
+
Finally, you can call methods such as `to_aoa`, `to_text`, etc., directly on a
|
|
2003
|
+
Table:
|
|
2004
|
+
|
|
2005
|
+
tab_a.to_aoa
|
|
2006
|
+
|
|
2007
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
2008
|
+
|----|-------|-----|------------|--------|------------|
|
|
2009
|
+
| 1 | Paul | 32 | California | 20000 | 2001-07-13 |
|
|
2010
|
+
| 3 | Teddy | 23 | Norway | 20000 | 2007-12-13 |
|
|
2011
|
+
| 4 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 |
|
|
2012
|
+
| 5 | David | 27 | Texas | 85000 | 2007-12-13 |
|
|
2013
|
+
| 2 | Allen | 25 | Texas | | 2005-07-13 |
|
|
2014
|
+
| 8 | Paul | 24 | Houston | 20000 | 2005-07-13 |
|
|
2015
|
+
| 9 | James | 44 | Norway | 5000 | 2005-07-13 |
|
|
2016
|
+
| 10 | James | 45 | Texas | 5000 | |
|
|
2017
|
+
|
|
2018
|
+
And you can supply a block to them as well to specify formatting or footers:
|
|
2019
|
+
|
|
2020
|
+
tab_a.to_aoa do |f|
|
|
2021
|
+
f.format(numeric: '0.0,R', id: '3.0C')
|
|
2022
|
+
f.sum_footer(:salary, :age)
|
|
2023
|
+
end
|
|
2024
|
+
|
|
2025
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
2026
|
+
|-------|-------|-----|------------|---------|------------|
|
|
2027
|
+
| 001 | Paul | 32 | California | 20,000 | 2001-07-13 |
|
|
2028
|
+
| 003 | Teddy | 23 | Norway | 20,000 | 2007-12-13 |
|
|
2029
|
+
| 004 | Mark | 25 | Rich-Mond | 65,000 | 2007-12-13 |
|
|
2030
|
+
| 005 | David | 27 | Texas | 85,000 | 2007-12-13 |
|
|
2031
|
+
| 002 | Allen | 25 | Texas | | 2005-07-13 |
|
|
2032
|
+
| 008 | Paul | 24 | Houston | 20,000 | 2005-07-13 |
|
|
2033
|
+
| 009 | James | 44 | Norway | 5,000 | 2005-07-13 |
|
|
2034
|
+
| 010 | James | 45 | Texas | 5,000 | |
|
|
2035
|
+
|-------|-------|-----|------------|---------|------------|
|
|
2036
|
+
| Total | | 245 | | 220,000 | |
|
|
2037
|
+
|
|
2038
|
+
|
|
2039
|
+
<a id="org7b25866"></a>
|
|
2040
|
+
|
|
2041
|
+
### The `format` and `format_for` methods
|
|
2042
|
+
|
|
2043
|
+
Formatters take only two kinds of methods, those that attach footers to a
|
|
2044
|
+
table, which are discussed in the next section, and those that specify
|
|
2045
|
+
formatting for table cells, which are the subject of this section.
|
|
2046
|
+
|
|
2047
|
+
To set formatting directives for all locations in a table at once, use the
|
|
2048
|
+
`format` method; to set formatting directives for a particular location in the
|
|
2049
|
+
table, use the `format_for` method, giving the location as the first parameter.
|
|
2050
|
+
|
|
2051
|
+
Other than that first parameter, the two methods take the same types of
|
|
2052
|
+
parameters. The remaining parameters are hash-like parameters that use either a
|
|
2053
|
+
column name or a type as the key and a string with the formatting directives to
|
|
2054
|
+
apply as the value. The following example says to set the formatting for all
|
|
2055
|
+
locations in the table and to format all numeric fields as strings that are
|
|
2056
|
+
rounded to whole numbers (the ’0.0’ part), that are right-aligned (the ’R’
|
|
2057
|
+
part), and have grouping commas inserted (the ’,’ part). But the `:id` column is
|
|
2058
|
+
numeric, and the second parameter overrides the formatting for numerics in
|
|
2059
|
+
general and calls for the `:id` column to be padded to three digits with zeros
|
|
2060
|
+
on the left (the ’3.0’ part) and to be centered (the ’C’ part).
|
|
2061
|
+
|
|
2062
|
+
tab_a.to_aoa do |f|
|
|
2063
|
+
f.format(numeric: '0.0,R', id: '3.0C')
|
|
2064
|
+
end
|
|
2065
|
+
|
|
2066
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
2067
|
+
|-----|-------|-----|------------|--------|------------|
|
|
2068
|
+
| 001 | Paul | 32 | California | 20,000 | 2001-07-13 |
|
|
2069
|
+
| 003 | Teddy | 23 | Norway | 20,000 | 2007-12-13 |
|
|
2070
|
+
| 004 | Mark | 25 | Rich-Mond | 65,000 | 2007-12-13 |
|
|
2071
|
+
| 005 | David | 27 | Texas | 85,000 | 2007-12-13 |
|
|
2072
|
+
| 002 | Allen | 25 | Texas | | 2005-07-13 |
|
|
2073
|
+
| 008 | Paul | 24 | Houston | 20,000 | 2005-07-13 |
|
|
2074
|
+
| 009 | James | 44 | Norway | 5,000 | 2005-07-13 |
|
|
2075
|
+
| 010 | James | 45 | Texas | 5,000 | |
|
|
2076
|
+
|
|
2077
|
+
The `numeric:` directive affected the `:age` and `:salary` columns and the `id:`
|
|
2078
|
+
directive affected only the `:id` column. All the other cells in the table had
|
|
2079
|
+
the default formatting applied.
|
|
2080
|
+
|
|
2081
|
+
1. Location priority
|
|
2082
|
+
|
|
2083
|
+
Formatting for any given cell depends on its location in the table. The
|
|
2084
|
+
`format_for` method takes a location to which its formatting directive are
|
|
2085
|
+
restricted as the first argument. It can be one of the following:
|
|
2086
|
+
|
|
2087
|
+
- **`:header`:** directive apply only to the header row, that is the first row, of
|
|
2088
|
+
the output table,
|
|
2089
|
+
|
|
2090
|
+
- **`:footer`:** directives apply to all the footer rows of the output table,
|
|
2091
|
+
regardless of how many there are,
|
|
2092
|
+
|
|
2093
|
+
- **`gfooter`:** directives apply to all group footer rows of the output tables,
|
|
2094
|
+
regardless of how many there are,
|
|
2095
|
+
|
|
2096
|
+
- **`:body`:** directives apply to all rows in the body of the table unless the
|
|
2097
|
+
row is the first row in the table or in a group and separate directives for
|
|
2098
|
+
those have been given, in which case those directives apply,
|
|
2099
|
+
|
|
2100
|
+
- **`:gfirst`:** directives apply to the first row in each group in the body of
|
|
2101
|
+
the table, unless the row is also the first row in the table as a whole, in
|
|
2102
|
+
which case the `:bfirst` directives apply,
|
|
2103
|
+
|
|
2104
|
+
- **`:bfirst`:** directives apply to the first row in the body of the table.
|
|
2105
|
+
|
|
2106
|
+
If you give directives for `:body`, they are copied to `:bfirst` and `:gfirst`
|
|
2107
|
+
as well and can be overridden by directives for those locations.
|
|
2108
|
+
|
|
2109
|
+
Directives given to the `format` method apply the directives to all locations in
|
|
2110
|
+
the table, but they can be overridden by more specific directives given in a
|
|
2111
|
+
`format_for` directive.
|
|
2112
|
+
|
|
2113
|
+
2. Type and Column priority
|
|
2114
|
+
|
|
2115
|
+
A directive based on type applies to all columns having that type unless
|
|
2116
|
+
overridden by a directive specific to a named column; a directive based on a
|
|
2117
|
+
column name applies only to cells in that column.
|
|
2118
|
+
|
|
2119
|
+
However, there is a twist. Since the end result of formatting is to convert all
|
|
2120
|
+
columns to strings, the formatting directives for the `:string` type applies to
|
|
2121
|
+
all columns. Likewise, since all columns may contain nils, the `nil:` type
|
|
2122
|
+
applies to nils in all columns regardless of the column’s type.
|
|
2123
|
+
|
|
2124
|
+
require 'fat_table'
|
|
2125
|
+
tab_a.to_text do |f|
|
|
2126
|
+
f.format(string: 'R', id: '3.0C', salary: 'n[N/A]')
|
|
2127
|
+
end
|
|
2128
|
+
|
|
2129
|
+
+=====+=======+=====+============+========+============+
|
|
2130
|
+
| Id | Name | Age | Address | Salary | Join Date |
|
|
2131
|
+
+-----|-------|-----|------------|--------|------------+
|
|
2132
|
+
| 001 | Paul | 32 | California | 20000 | 2001-07-13 |
|
|
2133
|
+
| 003 | Teddy | 23 | Norway | 20000 | 2007-12-13 |
|
|
2134
|
+
| 004 | Mark | 25 | Rich-Mond | 65000 | 2007-12-13 |
|
|
2135
|
+
| 005 | David | 27 | Texas | 85000 | 2007-12-13 |
|
|
2136
|
+
| 002 | Allen | 25 | Texas | N/A | 2005-07-13 |
|
|
2137
|
+
| 008 | Paul | 24 | Houston | 20000 | 2005-07-13 |
|
|
2138
|
+
| 009 | James | 44 | Norway | 5000 | 2005-07-13 |
|
|
2139
|
+
| 010 | James | 45 | Texas | 5000 | |
|
|
2140
|
+
+=====+=======+=====+============+========+============+
|
|
2141
|
+
|
|
2142
|
+
The `string: 'R'` directive causes all the cells to be right-aligned except
|
|
2143
|
+
`:id` which specifies centering for the `:id` column only. The `n[N/A]`
|
|
2144
|
+
directive for specifies how nil are displayed in the numeric column, `:salary`,
|
|
2145
|
+
but not for other nils, such as in the last row of the `:join_date` column.
|
|
2146
|
+
|
|
2147
|
+
|
|
2148
|
+
<a id="org62e325b"></a>
|
|
2149
|
+
|
|
2150
|
+
# Development
|
|
2151
|
+
|
|
2152
|
+
After checking out the repo, run \`bin/setup\` to install dependencies. Then, run
|
|
2153
|
+
\`rake spec\` to run the tests. You can also run \`bin/console\` for an interactive
|
|
2154
|
+
prompt that will allow you to experiment.
|
|
2155
|
+
|
|
2156
|
+
To install this gem onto your local machine, run \`bundle exec rake install\`. To
|
|
2157
|
+
release a new version, update the version number in \`version.rb\`, and then run
|
|
2158
|
+
\`bundle exec rake release\`, which will create a git tag for the version, push
|
|
2159
|
+
git commits and tags, and push the \`.gem\` file to
|
|
2160
|
+
[rubygems.org](<https://rubygems.org>).
|
|
2161
|
+
|
|
2162
|
+
|
|
2163
|
+
<a id="orgf51a2c9"></a>
|
|
2164
|
+
|
|
2165
|
+
# Contributing
|
|
2166
|
+
|
|
2167
|
+
Bug reports and pull requests are welcome on GitHub at
|
|
2168
|
+
<https://github.com/ddoherty03/fat_table>.
|