This is an automated email from the ASF dual-hosted git repository. thiru pushed a commit to branch fast-decoder-thiru in repository https://gitbox.apache.org/repos/asf/avro.git
commit cc71ce4abd087254403706b4c348b9169e92e3b4 Author: rstata <[email protected]> AuthorDate: Tue Apr 30 01:17:40 2019 -0700 More tweaks --- .../java/org/apache/avro/generic/Advancer.java | 40 ++++++++++------------ 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/generic/Advancer.java b/lang/java/avro/src/main/java/org/apache/avro/generic/Advancer.java index 9064a39..d75e9ee 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/generic/Advancer.java +++ b/lang/java/avro/src/main/java/org/apache/avro/generic/Advancer.java @@ -470,9 +470,6 @@ abstract class Advancer { public Advancer getBranchAdvancer(Decoder in, int branch) throws IOException { return branches[branch]; } - public Object next(Decoder in) throws IOException { - return branches[in.readIndex()].next(in); - } } private static class ReaderUnion extends Advancer { @@ -485,9 +482,6 @@ abstract class Advancer { throw new IllegalArgumentException("Branch much be " + branch + ", got " + b); return advancer; } - public Object next(Decoder in) throws IOException { - return advancer.next(in); - } } @@ -503,27 +497,29 @@ abstract class Advancer { * reader's fields. Thus, the following is how to read a record: * <pre> * for (int i = 0; i < a.advancers.length; i++) { - * dataum.set(a.readerOrder[i], a.advancers[i].next()); + * dataum.set(a.readerOrder[i].pos(), a.advancers[i].next(in)); * } - * a.done(); + * a.done(in); * </pre> * Note that a decoder <em>must</em> call {@link done} after interpreting * all the elemnts in {@link advancers}. * * As a convenience, {@link inOrder} is set to true iff the reader - * and writer order agrees (i.e., iff <code>readerOrder[i] == + * and writer order agrees (i.e., iff <code>readerOrder[i].pos() == * i</code> for all i). Generated code can use this to optimize this * common case. */ public static class Record extends Advancer { public final Advancer[] advancers; private Schema[] finalSkips; - public final int[] readerOrder; + public final Schema.Field[] readerOrder; public final boolean inOrder; - private Record(Advancer[] advancers, Schema[] finalSkips, int[] order, boolean inOrder) { + private Record(Advancer[] advancers, Schema[] finalSkips, + Schema.Field[] readerOrder, boolean inOrder) + { this.advancers = advancers; this.finalSkips = finalSkips; - this.readerOrder = order; + this.readerOrder = readerOrder; this.inOrder = inOrder; } @@ -540,8 +536,7 @@ abstract class Advancer { /** Special subclasses of Advance will encapsulate skipping. */ // Compute the "readerOrder" argument to Advancer.Record constructor - int[] readOrder = new int[ra.readerOrder.length]; - for (int i = 0; i < readOrder.length; i++) readOrder[i] = ra.readerOrder[i].pos(); + Schema.Field[] readOrder = ra.readerOrder; // Compute the "advancers" argument to Advancer.Record constructor Advancer[] fieldAdvs = new Advancer[readOrder.length]; @@ -573,15 +568,21 @@ abstract class Advancer { // record's field order not changing. boolean inOrder = true; for (int k = 0; k < ra.firstDefault-1; k++) - inOrder &= (readOrder[k] < readOrder[k+1]); + inOrder &= (readOrder[k].pos() < readOrder[k+1].pos()); if (inOrder) { Advancer[] newAdvancers = new Advancer[fieldAdvs.length]; + Schema.Field[] newReadOrder = new Schema.Field[fieldAdvs.length]; for (int k = 0, rf2 = 0, df = ra.firstDefault; k < readOrder.length; k++) { - if (readOrder[rf2] < readOrder[df]) newAdvancers[k] = fieldAdvs[rf2++]; - else newAdvancers[k] = fieldAdvs[df++]; + if (readOrder[rf2].pos() < readOrder[df].pos()) { + newAdvancers[k] = fieldAdvs[rf2]; + newReadOrder[k] = readOrder[rf2++]; + } else { + newAdvancers[k] = fieldAdvs[df]; + newReadOrder[k] = readOrder[df++]; + } } - for (int k = 0; k < readOrder.length; k++) readOrder[k] = k; fieldAdvs = newAdvancers; + readOrder = newReadOrder; } return new Record(fieldAdvs, finalSkips, readOrder, inOrder); @@ -596,9 +597,6 @@ abstract class Advancer { this.field = field; } - public Object next(Decoder in) throws IOException - { ignore(toSkip, in); return field.next(in); } - public Object nextNull(Decoder in) throws IOException { ignore(toSkip, in); return field.nextNull(in); }
