-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
BatchingRecordAccess.java
165 lines (142 loc) · 4.56 KB
/
BatchingRecordAccess.java
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
/*
* Copyright (c) 2002-2016 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.unsafe.impl.batchimport.store;
import java.util.Collection;
import org.neo4j.helpers.collection.IterableWrapper;
import org.neo4j.kernel.impl.transaction.state.NeoStoreTransactionContext;
import org.neo4j.kernel.impl.transaction.state.RecordAccess;
import org.neo4j.kernel.impl.util.collection.ArrayCollection;
/**
* {@link RecordAccess} optimized for batching and an access pattern where records are created sequentially.
* Mostly here as a bridge between a batch importer and existing record logic in {@link NeoStoreTransactionContext}
* and friends.
*/
public abstract class BatchingRecordAccess<KEY,RECORD,ADDITIONAL> implements RecordAccess<KEY,RECORD,ADDITIONAL>
{
private final Collection<RecordProxy<KEY,RECORD,ADDITIONAL>> proxies = new ArrayCollection<>( 1000 );
@Override
public RecordProxy<KEY,RECORD,ADDITIONAL> getOrLoad( KEY key, ADDITIONAL additionalData )
{
throw new UnsupportedOperationException( "We only support creations here" );
}
@Override
public RecordProxy<KEY,RECORD,ADDITIONAL> create( KEY key, ADDITIONAL additionalData )
{
RECORD record = createRecord( key, additionalData );
BatchingRecordProxy<KEY,RECORD,ADDITIONAL> proxy = new BatchingRecordProxy<>( key, record, additionalData );
proxies.add( proxy );
return proxy;
}
protected abstract RECORD createRecord( KEY key, ADDITIONAL additionalData );
public Iterable<RECORD> records()
{
return new IterableWrapper<RECORD,RecordProxy<KEY,RECORD,ADDITIONAL>>( proxies )
{
@Override
protected RECORD underlyingObjectToObject( RecordProxy<KEY,RECORD,ADDITIONAL> object )
{
return object.forReadingLinkage();
}
};
}
@Override
public RecordProxy<KEY,RECORD,ADDITIONAL> getIfLoaded( KEY key )
{
throw new UnsupportedOperationException( "Not supported" );
}
@Override
public void setTo( KEY key, RECORD newRecord, ADDITIONAL additionalData )
{
throw new UnsupportedOperationException( "Not supported" );
}
@Override
public int changeSize()
{
return proxies.size();
}
@Override
public Iterable<RecordProxy<KEY,RECORD,ADDITIONAL>> changes()
{
return proxies;
}
@Override
public void close()
{ // Fast clearing due to ArrayCollection
proxies.clear();
}
public static class BatchingRecordProxy<KEY,RECORD,ADDITIONAL> implements RecordProxy<KEY,RECORD,ADDITIONAL>
{
private final KEY key;
private final RECORD record;
private final ADDITIONAL additional;
private boolean changed;
private BatchingRecordProxy( KEY key, RECORD record, ADDITIONAL additional )
{
this.key = key;
this.record = record;
this.additional = additional;
}
@Override
public KEY getKey()
{
return key;
}
@Override
public RECORD forChangingLinkage()
{
return record;
}
@Override
public RECORD forChangingData()
{
return record;
}
@Override
public RECORD forReadingLinkage()
{
return record;
}
@Override
public RECORD forReadingData()
{
return record;
}
@Override
public ADDITIONAL getAdditionalData()
{
return additional;
}
@Override
public RECORD getBefore()
{
return null;
}
@Override
public boolean isChanged()
{
return true;
}
@Override
public boolean isCreated()
{
return true;
}
}
}