1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
Copyright (c) 2011 James Ahlborn
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA
*/
package com.healthmarketscience.jackcess;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* Utility for finding rows based on pre-defined, foreign-key table
* relationships.
*
* @author James Ahlborn
*/
public class Joiner
{
private final Index _fromIndex;
private final List<IndexData.ColumnDescriptor> _fromCols;
private final IndexCursor _toCursor;
private final Object[] _entryValues;
private Joiner(Index fromIndex, IndexCursor toCursor)
{
_fromIndex = fromIndex;
_fromCols = _fromIndex.getColumns();
_entryValues = new Object[_fromCols.size()];
_toCursor = toCursor;
}
/**
* Creates a new Joiner based on the foreign-key relationship between the
* given "from"" table and the given "to"" table.
*
* @param fromTable the "from" side of the relationship
* @param toTable the "to" side of the relationship
* @throws IllegalArgumentException if there is no relationship between the
* given tables
*/
public static Joiner create(Table fromTable, Table toTable)
throws IOException
{
return create(fromTable.getForeignKeyIndex(toTable));
}
/**
* Creates a new Joiner based on the given index which backs a foreign-key
* relationship. The table of the given index will be the "from" table and
* the table on the other end of the relationship will be the "to" table.
*
* @param fromIndex the index backing one side of a foreign-key relationship
*/
public static Joiner create(Index fromIndex)
throws IOException
{
Index toIndex = fromIndex.getReferencedIndex();
IndexCursor toCursor = IndexCursor.createCursor(
toIndex.getTable(), toIndex);
// text lookups are always case-insensitive
toCursor.setColumnMatcher(CaseInsensitiveColumnMatcher.INSTANCE);
return new Joiner(fromIndex, toCursor);
}
/**
* Creates a new Joiner that is the reverse of this Joiner (the "from" and
* "to" tables are swapped).
*/
public Joiner createReverse()
throws IOException
{
return create(getToTable(), getFromTable());
}
public Table getFromTable()
{
return getFromIndex().getTable();
}
public Index getFromIndex()
{
return _fromIndex;
}
public Table getToTable()
{
return getToCursor().getTable();
}
public Index getToIndex()
{
return getToCursor().getIndex();
}
public IndexCursor getToCursor()
{
return _toCursor;
}
/**
* Returns the first row in the "to" table based on the given columns in the
* "from" table if any, {@code null} if there is no matching row.
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
*/
public Map<String,Object> findFirstRow(Map<String,Object> fromRow)
throws IOException
{
return findFirstRow(fromRow, null);
}
/**
* Returns selected columns from the first row in the "to" table based on
* the given columns in the "from" table if any, {@code null} if there is no
* matching row.
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
* @param columnNames desired columns in the from table row
*/
public Map<String,Object> findFirstRow(Map<String,Object> fromRow,
Collection<String> columnNames)
throws IOException
{
toEntryValues(fromRow);
return ((_toCursor.findRowByEntry(_entryValues) ?
_toCursor.getCurrentRow(columnNames) : null));
}
/**
* Returns an Iterator over all the rows in the "to" table based on the
* given columns in the "from" table.
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
*/
public Iterator<Map<String,Object>> findRows(Map<String,Object> fromRow)
{
return findRows(fromRow, null);
}
/**
* Returns an Iterator with the selected columns over all the rows in the
* "to" table based on the given columns in the "from" table.
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
* @param columnNames desired columns in the from table row
*/
public Iterator<Map<String,Object>> findRows(Map<String,Object> fromRow,
Collection<String> columnNames)
{
toEntryValues(fromRow);
return _toCursor.entryIterator(columnNames, _entryValues);
}
/**
* Returns an Iterable whose iterator() method returns the result of a call
* to {@link #findRows(Map)}
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
* @throws IllegalStateException if an IOException is thrown by one of the
* operations, the actual exception will be contained within
*/
public Iterable<Map<String,Object>> findRowsIterable(
Map<String,Object> fromRow)
{
return findRowsIterable(fromRow, null);
}
/**
* Returns an Iterable whose iterator() method returns the result of a call
* to {@link #findRows(Map,Collection)}
*
* @param fromRow row from the "from" table (which must include the relevant
* columns for this join relationship)
* @param columnNames desired columns in the from table row
* @throws IllegalStateException if an IOException is thrown by one of the
* operations, the actual exception will be contained within
*/
public Iterable<Map<String,Object>> findRowsIterable(
final Map<String,Object> fromRow, final Collection<String> columnNames)
{
return new Iterable<Map<String, Object>>() {
public Iterator<Map<String, Object>> iterator() {
return findRows(fromRow, columnNames);
}
};
}
/**
* Fills in the _entryValues with the relevant info from the given "from"
* table row.
*/
private void toEntryValues(Map<String,Object> fromRow)
{
for(int i = 0; i < _entryValues.length; ++i) {
_entryValues[i] = fromRow.get(_fromCols.get(i).getName());
}
}
}
|
