[GitHub] [arrow] liyafan82 commented on a change in pull request #7275: ARROW-6110: [Java][Integration] Support LargeList Type and add integration test with C++

[GitBox <gi...@apache.org>]

liyafan82 commented on a change in pull request #7275:
URL: https://github.com/apache/arrow/pull/7275#discussion_r439373604



##########
File path: java/vector/src/main/codegen/templates/UnionLargeListWriter.java
##########
@@ -0,0 +1,232 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.arrow.memory.ArrowBuf;
+import org.apache.arrow.vector.complex.writer.DecimalWriter;
+import org.apache.arrow.vector.holders.DecimalHolder;
+
+import java.lang.UnsupportedOperationException;
+import java.math.BigDecimal;
+
+<@pp.dropOutputFile />
+<@pp.changeOutputFile name="/org/apache/arrow/vector/complex/impl/UnionLargeListWriter.java" />
+
+
+<#include "/@includes/license.ftl" />
+
+package org.apache.arrow.vector.complex.impl;
+
+    import static org.apache.arrow.memory.util.LargeMemoryUtil.checkedCastToInt;
+<#include "/@includes/vv_imports.ftl" />
+
+/*
+ * This class is generated using freemarker and the ${.template_name} template.
+ */
+
+@SuppressWarnings("unused")
+public class UnionLargeListWriter extends AbstractFieldWriter {
+
+  protected LargeListVector vector;
+  protected PromotableWriter writer;
+  private long index = 0L;
+  private boolean inStruct = false;
+  private String structName;
+  private static final int OFFSET_WIDTH = 8;
+
+  public UnionLargeListWriter(LargeListVector vector) {
+    this(vector, NullableStructWriterFactory.getNullableStructWriterFactoryInstance());
+  }
+
+  public UnionLargeListWriter(LargeListVector vector, NullableStructWriterFactory nullableStructWriterFactory) {
+    this.vector = vector;
+    this.writer = new PromotableWriter(vector.getDataVector(), vector, nullableStructWriterFactory);
+  }
+
+  public UnionLargeListWriter(LargeListVector vector, AbstractFieldWriter parent) {
+    this(vector);
+  }
+
+  @Override
+  public void allocate() {
+    vector.allocateNew();
+  }
+
+  @Override
+  public void clear() {
+    vector.clear();
+  }
+
+  @Override
+  public Field getField() {
+    return vector.getField();
+  }
+
+  public void setValueCount(int count) {
+    vector.setValueCount(count);
+  }
+
+  @Override
+  public int getValueCapacity() {
+    return vector.getValueCapacity();
+  }
+
+  @Override
+  public void close() throws Exception {
+    vector.close();
+    writer.close();
+  }
+
+  @Override
+  public void setPosition(int index) {
+    throw new UnsupportedOperationException("cant set int index for long list");
+  }
+
+  public void setIndex(long index) {
+    this.index = index;
+  }
+  <#list vv.types as type><#list type.minor as minor><#assign name = minor.class?cap_first />
+  <#assign fields = minor.fields!type.fields />
+  <#assign uncappedName = name?uncap_first/>
+  <#if uncappedName == "int" ><#assign uncappedName = "integer" /></#if>
+  <#if !minor.typeParams?? >
+
+  @Override
+  public ${name}Writer ${uncappedName}() {
+    return this;
+  }
+
+  @Override
+  public ${name}Writer ${uncappedName}(String name) {
+    structName = name;
+    return writer.${uncappedName}(name);
+  }
+  </#if>
+  </#list></#list>
+
+  @Override
+  public DecimalWriter decimal() {
+    return this;
+  }
+
+  @Override
+  public DecimalWriter decimal(String name, int scale, int precision) {
+    return writer.decimal(name, scale, precision);
+  }
+
+  @Override
+  public DecimalWriter decimal(String name) {
+    return writer.decimal(name);
+  }
+
+  @Override
+  public StructWriter struct() {
+    inStruct = true;
+    return this;
+  }
+
+  @Override
+  public ListWriter list() {
+    return writer;
+  }
+
+  @Override
+  public ListWriter list(String name) {
+    ListWriter listWriter = writer.list(name);
+    return listWriter;
+  }
+
+  @Override
+  public StructWriter struct(String name) {
+    StructWriter structWriter = writer.struct(name);
+    return structWriter;
+  }
+
+  @Override
+  public void startList() {
+    vector.startNewValue(index);
+    writer.setPosition(checkedCastToInt(vector.getOffsetBuffer().getLong((index + 1) * OFFSET_WIDTH)));

Review comment:
       Here we need to cast the argument of getLong to long, to avoid integer overflow. 




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org