Github user ramkrish86 commented on a diff in the pull request:

    https://github.com/apache/incubator-phoenix/pull/8#discussion_r9948567
  
    --- Diff: 
phoenix-core/src/main/java/org/apache/phoenix/expression/ArrayConstructorExpression.java
 ---
    @@ -62,27 +63,54 @@ public void reset() {
             position = 0;
             Arrays.fill(elements, null);
         }
    -    
    +
         @Override
         public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) {
    -        for (int i = position >= 0 ? position : 0; i < elements.length; 
i++) {
    -            Expression child = children.get(i);
    -            if (!child.evaluate(tuple, ptr)) {
    -                if (tuple != null && !tuple.isImmutable()) {
    -                    if (position >= 0) position = i;
    -                    return false;
    +        try {
    +            int offset = 0;
    +            // track the elementlength for variable array
    +            int noOfElements =  children.size();
    +            int elementLength = 0;
    +            byteStream = new TrustedByteArrayOutputStream(estimatedSize);
    +            oStream = new DataOutputStream(byteStream);
    +            for (int i = position >= 0 ? position : 0; i < 
elements.length; i++) {
    +                Expression child = children.get(i);
    +                if (!child.evaluate(tuple, ptr)) {
    +                    if (tuple != null && !tuple.isImmutable()) {
    +                        if (position >= 0) position = i;
    +                        return false;
    +                    }
    +                } else {
    +                    // track the offset position here from the size of the 
byteStream
    +                    if (!baseType.isFixedWidth()) {
    +                        offset = byteStream.size();
    +                        offsetPos[i] = offset;
    --- End diff --
    
    The serailization and deserialization is becoming tougher with these null 
values.  We will not be able to calculate the correct offset with the above 
code and existing deserialization logic.  We will have to persist the number of 
trailing nulls also.
    I will make the changes and send it to you. Lot of logic needs to done to 
identify that a null was written but for consecutive nulls.  And also if it is 
a trailing null, then we may have then the offset would be populated of the 
previous element and in the deserialization when we start comparing the 
previous and the current we are not sure whether the last one was a null. 


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. To do so, please top-post your response.
If your project does not have this feature enabled and wishes so, or if the
feature is enabled but not working, please contact infrastructure at
[email protected] or file a JIRA ticket with INFRA.
---

Reply via email to