PHOENIX-1705 implement ARRAY_APPEND built in function (Dumindu Buddhika)
Project: http://git-wip-us.apache.org/repos/asf/phoenix/repo Commit: http://git-wip-us.apache.org/repos/asf/phoenix/commit/7ef17181 Tree: http://git-wip-us.apache.org/repos/asf/phoenix/tree/7ef17181 Diff: http://git-wip-us.apache.org/repos/asf/phoenix/diff/7ef17181 Branch: refs/heads/calcite Commit: 7ef1718127ffaa99adbc4c25ec3715d9472464f9 Parents: 986080f Author: James Taylor <[email protected]> Authored: Tue Apr 14 12:07:29 2015 -0700 Committer: James Taylor <[email protected]> Committed: Tue Apr 14 12:07:29 2015 -0700 ---------------------------------------------------------------------- .../phoenix/end2end/ArrayAppendFunctionIT.java | 667 +++++++++++++++++++ .../function/ArrayAppendFunction.java | 127 ++++ .../expression/ArrayAppendFunctionTest.java | 345 ++++++++++ 3 files changed, 1139 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/phoenix/blob/7ef17181/phoenix-core/src/it/java/org/apache/phoenix/end2end/ArrayAppendFunctionIT.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/it/java/org/apache/phoenix/end2end/ArrayAppendFunctionIT.java b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ArrayAppendFunctionIT.java new file mode 100644 index 0000000..1957b3a --- /dev/null +++ b/phoenix-core/src/it/java/org/apache/phoenix/end2end/ArrayAppendFunctionIT.java @@ -0,0 +1,667 @@ +/* + * 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. + */ +package org.apache.phoenix.end2end; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.sql.*; + +import org.apache.phoenix.schema.TypeMismatchException; +import org.junit.Test; + +public class ArrayAppendFunctionIT extends BaseHBaseManagedTimeIT { + private void initTables(Connection conn) throws Exception { + String ddl = "CREATE TABLE regions (region_name VARCHAR PRIMARY KEY,varchars VARCHAR[],integers INTEGER[],doubles DOUBLE[],bigints BIGINT[],chars CHAR(15)[],double1 DOUBLE,char1 CHAR(17),nullcheck INTEGER,chars2 CHAR(15)[])"; + conn.createStatement().execute(ddl); + String dml = "UPSERT INTO regions(region_name,varchars,integers,doubles,bigints,chars,double1,char1,nullcheck,chars2) VALUES('SF Bay Area'," + + "ARRAY['2345','46345','23234']," + + "ARRAY[2345,46345,23234,456]," + + "ARRAY[23.45,46.345,23.234,45.6,5.78]," + + "ARRAY[12,34,56,78,910]," + + "ARRAY['a','bbbb','c','ddd','e']," + + "23.45," + + "'wert'," + + "NULL," + + "ARRAY['a','bbbb','c','ddd','e','foo']" + + ")"; + PreparedStatement stmt = conn.prepareStatement(dml); + stmt.execute(); + conn.commit(); + } + + private void initTablesDesc(Connection conn, String type, String val) throws Exception { + String ddl = "CREATE TABLE regions (pk " + type + " PRIMARY KEY DESC,varchars VARCHAR[],integers INTEGER[],doubles DOUBLE[],bigints BIGINT[],chars CHAR(15)[],chars2 CHAR(15)[], bools BOOLEAN[])"; + conn.createStatement().execute(ddl); + String dml = "UPSERT INTO regions(pk,varchars,integers,doubles,bigints,chars,chars2,bools) VALUES(" + val + "," + + "ARRAY['2345','46345','23234']," + + "ARRAY[2345,46345,23234,456]," + + "ARRAY[23.45,46.345,23.234,45.6,5.78]," + + "ARRAY[12,34,56,78,910]," + + "ARRAY['a','bbbb','c','ddd','e']," + + "ARRAY['a','bbbb','c','ddd','e','foo']," + + "ARRAY[true,false]" + + ")"; + PreparedStatement stmt = conn.prepareStatement(dml); + stmt.execute(); + conn.commit(); + } + + @Test + public void testArrayAppendFunctionVarchar() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(varchars,'34567') FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"2345", "46345", "23234", "34567"}; + + Array array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInteger() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(integers,1234) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{2345, 46345, 23234, 456, 1234}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionDouble() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(doubles,double1) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{23.45, 46.345, 23.234, 45.6, 5.78, 23.45}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionDouble2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(doubles,23) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{23.45, 46.345, 23.234, 45.6, 5.78, new Double(23)}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionBigint() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(bigints,1112) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Long[] longs = new Long[]{12l, 34l, 56l, 78l, 910l, 1112l}; + + Array array = conn.createArrayOf("BIGINT", longs); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionChar() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(chars,'fac') FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"a", "bbbb", "c", "ddd", "e", "fac"}; + + Array array = conn.createArrayOf("CHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test(expected = TypeMismatchException.class) + public void testArrayAppendFunctionIntToCharArray() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(varchars,234) FROM regions WHERE region_name = 'SF Bay Area'"); + } + + @Test(expected = TypeMismatchException.class) + public void testArrayAppendFunctionVarcharToIntegerArray() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(integers,'234') FROM regions WHERE region_name = 'SF Bay Area'"); + + } + + @Test(expected = SQLException.class) + public void testArrayAppendFunctionChar2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(chars,'facfacfacfacfacfacfac') FROM regions WHERE region_name = 'SF Bay Area'"); + rs.next(); + rs.getArray(1); + } + + @Test + public void testArrayAppendFunctionIntegerToDoubleArray() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(doubles,45) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{23.45, 46.345, 23.234, 45.6, 5.78, 45.0}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithNestedFunctions1() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(ARRAY[23,45],integers[1]) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{23, 45, 2345}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithNestedFunctions2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(integers,ARRAY_ELEM(ARRAY[2,4],1)) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{2345, 46345, 23234, 456, 2}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithNestedFunctions3() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(doubles,ARRAY_ELEM(doubles,2)) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{23.45, 46.345, 23.234, 45.6, 5.78, 46.345}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithUpsert1() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + + String ddl = "CREATE TABLE regions (region_name VARCHAR PRIMARY KEY,varchars VARCHAR[])"; + conn.createStatement().execute(ddl); + + String dml = "UPSERT INTO regions(region_name,varchars) VALUES('SF Bay Area',ARRAY_APPEND(ARRAY['hello','world'],':-)'))"; + conn.createStatement().execute(dml); + conn.commit(); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT varchars FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"hello", "world", ":-)"}; + + Array array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithUpsert2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + + String ddl = "CREATE TABLE regions (region_name VARCHAR PRIMARY KEY,integers INTEGER[])"; + conn.createStatement().execute(ddl); + + String dml = "UPSERT INTO regions(region_name,integers) VALUES('SF Bay Area',ARRAY_APPEND(ARRAY[4,5],6))"; + conn.createStatement().execute(dml); + conn.commit(); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT integers FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{4, 5, 6}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithUpsert3() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + + String ddl = "CREATE TABLE regions (region_name VARCHAR PRIMARY KEY,doubles DOUBLE[])"; + conn.createStatement().execute(ddl); + + String dml = "UPSERT INTO regions(region_name,doubles) VALUES('SF Bay Area',ARRAY_APPEND(ARRAY[5.67,7.87],9.0))"; + conn.createStatement().execute(dml); + conn.commit(); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT doubles FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{5.67, 7.87, new Double(9)}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithUpsertSelect1() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + + String ddl = "CREATE TABLE source (region_name VARCHAR PRIMARY KEY,doubles DOUBLE[])"; + conn.createStatement().execute(ddl); + + ddl = "CREATE TABLE target (region_name VARCHAR PRIMARY KEY,doubles DOUBLE[])"; + conn.createStatement().execute(ddl); + + String dml = "UPSERT INTO source(region_name,doubles) VALUES('SF Bay Area',ARRAY_APPEND(ARRAY[5.67,7.87],9.0))"; + conn.createStatement().execute(dml); + + dml = "UPSERT INTO source(region_name,doubles) VALUES('SF Bay Area2',ARRAY_APPEND(ARRAY[56.7,7.87],9.2))"; + conn.createStatement().execute(dml); + conn.commit(); + + dml = "UPSERT INTO target(region_name, doubles) SELECT region_name, ARRAY_APPEND(doubles,5) FROM source"; + conn.createStatement().execute(dml); + conn.commit(); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT doubles FROM target"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{5.67, 7.87, new Double(9), new Double(5)}; + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertTrue(rs.next()); + + doubles = new Double[]{56.7, 7.87, new Double(9.2), new Double(5)}; + array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithUpsertSelect2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + + String ddl = "CREATE TABLE source (region_name VARCHAR PRIMARY KEY,varchars VARCHAR[])"; + conn.createStatement().execute(ddl); + + ddl = "CREATE TABLE target (region_name VARCHAR PRIMARY KEY,varchars VARCHAR[])"; + conn.createStatement().execute(ddl); + + String dml = "UPSERT INTO source(region_name,varchars) VALUES('SF Bay Area',ARRAY_APPEND(ARRAY['abcd','b'],'c'))"; + conn.createStatement().execute(dml); + + dml = "UPSERT INTO source(region_name,varchars) VALUES('SF Bay Area2',ARRAY_APPEND(ARRAY['d','fgh'],'something'))"; + conn.createStatement().execute(dml); + conn.commit(); + + dml = "UPSERT INTO target(region_name, varchars) SELECT region_name, ARRAY_APPEND(varchars,'stu') FROM source"; + conn.createStatement().execute(dml); + conn.commit(); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT varchars FROM target"); + assertTrue(rs.next()); + + String[] strings = new String[]{"abcd", "b", "c", "stu"}; + Array array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertTrue(rs.next()); + + strings = new String[]{"d", "fgh", "something", "stu"}; + array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere1() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE ARRAY[2345,46345,23234,456,123]=ARRAY_APPEND(integers,123)"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere2() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE varchars[1]=ANY(ARRAY_APPEND(ARRAY['2345','46345','23234'],'1234'))"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere3() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE ARRAY['2345','46345','23234','1234']=ARRAY_APPEND(ARRAY['2345','46345','23234'],'1234')"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere4() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE ARRAY[23.45,4634.5,2.3234,123.4]=ARRAY_APPEND(ARRAY[23.45,4634.5,2.3234],123.4)"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere5() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE ARRAY['2345','46345','23234','foo']=ARRAY_APPEND(varchars,'foo')"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere6() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE chars2=ARRAY_APPEND(chars,'foo')"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionInWhere7() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT region_name FROM regions WHERE ARRAY[2,3,4]=ARRAY_APPEND(ARRAY[2,3],4)"); + assertTrue(rs.next()); + + assertEquals("SF Bay Area", rs.getString(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionIntegerWithNull() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(NULL,NULL) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{2345, 46345, 23234, 456}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(null, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionVarcharWithNull() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(varchars,NULL) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"2345", "46345", "23234"}; + + Array array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionDoublesWithNull() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(doubles,NULL) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Double[] doubles = new Double[]{23.45, 46.345, 23.234, 45.6, 5.78}; + + Array array = conn.createArrayOf("DOUBLE", doubles); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionCharsWithNull() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(chars,NULL) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"a", "bbbb", "c", "ddd", "e"}; + + Array array = conn.createArrayOf("CHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionWithNull() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(integers,nullcheck) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{2345, 46345, 23234, 456}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test(expected = SQLException.class) + public void testArrayAppendFunctionCharLimitCheck() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTables(conn); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(chars,char1) FROM regions WHERE region_name = 'SF Bay Area'"); + assertTrue(rs.next()); + + String[] strings = new String[]{"a", "bbbb", "c", "ddd", "e", "wert"}; + + Array array = conn.createArrayOf("CHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionIntegerDesc() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTablesDesc(conn, "INTEGER", "23"); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(integers,pk) FROM regions"); + assertTrue(rs.next()); + + Integer[] integers = new Integer[]{2345, 46345, 23234, 456, 23}; + + Array array = conn.createArrayOf("INTEGER", integers); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + + } + + @Test + public void testArrayAppendFunctionVarcharDesc() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTablesDesc(conn, "VARCHAR", "'e'"); + + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(varchars,pk) FROM regions"); + assertTrue(rs.next()); + + String[] strings = new String[]{"2345", "46345", "23234", "e"}; + + Array array = conn.createArrayOf("VARCHAR", strings); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionBigIntDesc() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTablesDesc(conn, "BIGINT", "1112"); + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(bigints,pk) FROM regions"); + assertTrue(rs.next()); + + Long[] longs = new Long[]{12l, 34l, 56l, 78l, 910l, 1112l}; + + Array array = conn.createArrayOf("BIGINT", longs); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } + + @Test + public void testArrayAppendFunctionBooleanDesc() throws Exception { + Connection conn = DriverManager.getConnection(getUrl()); + initTablesDesc(conn, "BOOLEAN", "false"); + ResultSet rs; + rs = conn.createStatement().executeQuery("SELECT ARRAY_APPEND(bools,pk) FROM regions"); + assertTrue(rs.next()); + + Boolean[] booleans = new Boolean[]{true, false, false}; + + Array array = conn.createArrayOf("BOOLEAN", booleans); + + assertEquals(array, rs.getArray(1)); + assertFalse(rs.next()); + } +} http://git-wip-us.apache.org/repos/asf/phoenix/blob/7ef17181/phoenix-core/src/main/java/org/apache/phoenix/expression/function/ArrayAppendFunction.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/main/java/org/apache/phoenix/expression/function/ArrayAppendFunction.java b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/ArrayAppendFunction.java new file mode 100644 index 0000000..db92d61 --- /dev/null +++ b/phoenix-core/src/main/java/org/apache/phoenix/expression/function/ArrayAppendFunction.java @@ -0,0 +1,127 @@ +/* + * 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. + */ +package org.apache.phoenix.expression.function; + +import java.util.List; + +import org.apache.hadoop.hbase.io.ImmutableBytesWritable; +import org.apache.phoenix.exception.DataExceedsCapacityException; +import org.apache.phoenix.expression.Expression; +import org.apache.phoenix.expression.LiteralExpression; +import org.apache.phoenix.parse.FunctionParseNode; +import org.apache.phoenix.schema.SortOrder; +import org.apache.phoenix.schema.TypeMismatchException; +import org.apache.phoenix.schema.types.*; +import org.apache.phoenix.schema.tuple.Tuple; + [email protected](name = ArrayAppendFunction.NAME, args = { + @FunctionParseNode.Argument(allowedTypes = {PBinaryArray.class, + PVarbinaryArray.class}), + @FunctionParseNode.Argument(allowedTypes = {PVarbinary.class}, defaultValue = "null")}) +public class ArrayAppendFunction extends ScalarFunction { + + public static final String NAME = "ARRAY_APPEND"; + + public ArrayAppendFunction() { + } + + public ArrayAppendFunction(List<Expression> children) throws TypeMismatchException { + super(children); + + if (getDataType() != null && !(getElementExpr() instanceof LiteralExpression && getElementExpr().isNullable()) && !getElementDataType().isCoercibleTo(getBaseType())) { + throw TypeMismatchException.newException(getBaseType(), getElementDataType()); + } + + // If the base type of an element is fixed width, make sure the element being appended will fit + if (getDataType() != null && getElementExpr().getDataType().getByteSize() == null && getElementDataType() != null && getBaseType().isFixedWidth() && getElementDataType().isFixedWidth() && getArrayExpr().getMaxLength() != null && + getElementExpr().getMaxLength() != null && getElementExpr().getMaxLength() > getArrayExpr().getMaxLength()) { + throw new DataExceedsCapacityException(""); + } + // If the base type has a scale, make sure the element being appended has a scale less than or equal to it + if (getDataType() != null && getArrayExpr().getScale() != null && getElementExpr().getScale() != null && + getElementExpr().getScale() > getArrayExpr().getScale()) { + throw new DataExceedsCapacityException(getBaseType(), getArrayExpr().getMaxLength(), getArrayExpr().getScale()); + } + } + + @Override + public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { + + if (!getArrayExpr().evaluate(tuple, ptr)) { + return false; + } else if (ptr.getLength() == 0) { + return true; + } + int arrayLength = PArrayDataType.getArrayLength(ptr, getBaseType(), getArrayExpr().getMaxLength()); + + int length = ptr.getLength(); + int offset = ptr.getOffset(); + byte[] arrayBytes = ptr.get(); + + if (!getElementExpr().evaluate(tuple, ptr) || ptr.getLength() == 0) { + ptr.set(arrayBytes, offset, length); + return true; + } + + if (!getBaseType().isSizeCompatible(ptr, null, getElementDataType(), getElementExpr().getMaxLength(), getElementExpr().getScale(), getArrayExpr().getMaxLength(), getArrayExpr().getScale())) { + throw new DataExceedsCapacityException(""); + } + + getBaseType().coerceBytes(ptr, null, getElementDataType(), getElementExpr().getMaxLength(), getElementExpr().getScale(), getElementExpr().getSortOrder(), getArrayExpr().getMaxLength(), getArrayExpr().getScale(), getArrayExpr().getSortOrder()); + + return PArrayDataType.appendItemToArray(ptr, length, offset, arrayBytes, getBaseType(), arrayLength, getMaxLength(), getArrayExpr().getSortOrder()); + } + + @Override + public PDataType getDataType() { + return children.get(0).getDataType(); + } + + @Override + public Integer getMaxLength() { + return this.children.get(0).getMaxLength(); + } + + @Override + public SortOrder getSortOrder() { + return getChildren().get(0).getSortOrder(); + } + + @Override + public String getName() { + return NAME; + } + + public Expression getArrayExpr() { + return getChildren().get(0); + } + + public Expression getElementExpr() { + return getChildren().get(1); + } + + public PDataType getBaseType() { + return PDataType.arrayBaseType(getArrayExpr().getDataType()); + } + + public PDataType getElementDataType() { + return getElementExpr().getDataType(); + } + + +} http://git-wip-us.apache.org/repos/asf/phoenix/blob/7ef17181/phoenix-core/src/test/java/org/apache/phoenix/expression/ArrayAppendFunctionTest.java ---------------------------------------------------------------------- diff --git a/phoenix-core/src/test/java/org/apache/phoenix/expression/ArrayAppendFunctionTest.java b/phoenix-core/src/test/java/org/apache/phoenix/expression/ArrayAppendFunctionTest.java new file mode 100644 index 0000000..2b4cb84 --- /dev/null +++ b/phoenix-core/src/test/java/org/apache/phoenix/expression/ArrayAppendFunctionTest.java @@ -0,0 +1,345 @@ +/* + * 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. + */ +package org.apache.phoenix.expression; + +import static org.junit.Assert.assertTrue; + +import java.math.BigDecimal; +import java.sql.SQLException; +import java.util.Calendar; +import java.util.List; + +import org.apache.hadoop.hbase.io.ImmutableBytesWritable; +import org.apache.phoenix.expression.function.ArrayAppendFunction; +import org.apache.phoenix.schema.SortOrder; +import org.apache.phoenix.schema.types.*; +import org.junit.Test; + +import com.google.common.collect.Lists; + +public class ArrayAppendFunctionTest { + + private static void testExpression(LiteralExpression array, LiteralExpression element, PhoenixArray expected) + throws SQLException { + List<Expression> expressions = Lists.newArrayList((Expression) array); + expressions.add(element); + + Expression arrayAppendFunction = new ArrayAppendFunction(expressions); + ImmutableBytesWritable ptr = new ImmutableBytesWritable(); + arrayAppendFunction.evaluate(null, ptr); + PhoenixArray result = (PhoenixArray) arrayAppendFunction.getDataType().toObject(ptr, expressions.get(0).getSortOrder(), array.getMaxLength(), array.getScale()); + assertTrue(result.equals(expected)); + } + + private static void test(PhoenixArray array, Object element, PDataType arrayDataType, Integer arrMaxLen, Integer arrScale, PDataType elementDataType, Integer elemMaxLen, Integer elemScale, PhoenixArray expected, SortOrder arraySortOrder, SortOrder elementSortOrder) throws SQLException { + LiteralExpression arrayLiteral, elementLiteral; + arrayLiteral = LiteralExpression.newConstant(array, arrayDataType, arrMaxLen, arrScale, arraySortOrder, Determinism.ALWAYS); + elementLiteral = LiteralExpression.newConstant(element, elementDataType, elemMaxLen, elemScale, elementSortOrder, Determinism.ALWAYS); + testExpression(arrayLiteral, elementLiteral, expected); + } + + @Test + public void testArrayAppendFunction1() throws Exception { + Object[] o = new Object[]{1, 2, -3, 4}; + Object[] o2 = new Object[]{1, 2, -3, 4, 5}; + Object element = 5; + PDataType baseType = PInteger.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction2() throws Exception { + Object[] o = new Object[]{"1", "2", "3", "4"}; + Object[] o2 = new Object[]{"1", "2", "3", "4", "56"}; + Object element = "56"; + PDataType baseType = PVarchar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction3() throws Exception { + //offset array short to int transition + Object[] o = new Object[Short.MAX_VALUE + 1]; + for (int i = 0; i < o.length; i++) { + o[i] = "a"; + } + Object[] o2 = new Object[Short.MAX_VALUE + 2]; + for (int i = 0; i < o2.length - 1; i++) { + o2[i] = "a"; + } + Object element = "b"; + o2[o2.length - 1] = element; + PDataType baseType = PVarchar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction4() throws Exception { + //offset array int + Object[] o = new Object[Short.MAX_VALUE + 7]; + for (int i = 0; i < o.length; i++) { + o[i] = "a"; + } + Object[] o2 = new Object[Short.MAX_VALUE + 8]; + for (int i = 0; i < o2.length - 1; i++) { + o2[i] = "a"; + } + Object element = "b"; + o2[o2.length - 1] = element; + PDataType baseType = PVarchar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction5() throws Exception { + Boolean[] o = new Boolean[]{true, false, false, true}; + Boolean[] o2 = new Boolean[]{true, false, false, true, false}; + Boolean element = false; + PDataType baseType = PBoolean.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction6() throws Exception { + Object[] o = new Object[]{new Float(2.3), new Float(7.9), new Float(-9.6), new Float(2.3)}; + Object[] o2 = new Object[]{new Float(2.3), new Float(7.9), new Float(-9.6), new Float(2.3), new Float(8.9)}; + Object element = 8.9; + PDataType baseType = PFloat.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveFloatPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveFloatPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction7() throws Exception { + Object[] o = new Object[]{4.78, 9.54, 2.34, -9.675, Double.MAX_VALUE}; + Object[] o2 = new Object[]{4.78, 9.54, 2.34, -9.675, Double.MAX_VALUE, 12.67}; + Object element = 12.67; + PDataType baseType = PDouble.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveDoublePhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveDoublePhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction8() throws Exception { + Object[] o = new Object[]{123l, 677l, 98789l, -78989l, 66787l}; + Object[] o2 = new Object[]{123l, 677l, 98789l, -78989l, 66787l, 543l}; + Object element = 543l; + PDataType baseType = PLong.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveLongPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveLongPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction9() throws Exception { + Object[] o = new Object[]{(short) 34, (short) -23, (short) -89, (short) 999, (short) 34}; + Object[] o2 = new Object[]{(short) 34, (short) -23, (short) -89, (short) 999, (short) 34, (short) 7}; + Object element = (short) 7; + PDataType baseType = PSmallint.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveShortPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveShortPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction10() throws Exception { + Object[] o = new Object[]{(byte) 4, (byte) 8, (byte) 9}; + Object[] o2 = new Object[]{(byte) 4, (byte) 8, (byte) 9, (byte) 6}; + Object element = (byte) 6; + PDataType baseType = PTinyint.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveBytePhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveBytePhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction11() throws Exception { + Object[] o = new Object[]{BigDecimal.valueOf(2345), BigDecimal.valueOf(-23.45), BigDecimal.valueOf(785)}; + Object[] o2 = new Object[]{BigDecimal.valueOf(2345), BigDecimal.valueOf(-23.45), BigDecimal.valueOf(785), BigDecimal.valueOf(-19)}; + Object element = BigDecimal.valueOf(-19); + PDataType baseType = PDecimal.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction12() throws Exception { + Calendar calendar = Calendar.getInstance(); + java.util.Date currentDate = calendar.getTime(); + java.sql.Date date = new java.sql.Date(currentDate.getTime()); + + Object[] o = new Object[]{date, date, date}; + Object[] o2 = new Object[]{date, date, date, date}; + PDataType baseType = PDate.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, date, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction13() throws Exception { + Calendar calendar = Calendar.getInstance(); + java.util.Date currentDate = calendar.getTime(); + java.sql.Time time = new java.sql.Time(currentDate.getTime()); + + Object[] o = new Object[]{time, time, time}; + Object[] o2 = new Object[]{time, time, time, time}; + PDataType baseType = PTime.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, time, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction14() throws Exception { + Calendar calendar = Calendar.getInstance(); + java.util.Date currentDate = calendar.getTime(); + java.sql.Timestamp timestamp = new java.sql.Timestamp(currentDate.getTime()); + + Object[] o = new Object[]{timestamp, timestamp, timestamp}; + Object[] o2 = new Object[]{timestamp, timestamp, timestamp, timestamp}; + PDataType baseType = PTimestamp.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, timestamp, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction15() throws Exception { + Object[] o = new Object[]{1, 2, -3, 4}; + Object[] o2 = new Object[]{1, 2, -3, 4, 5}; + Object element = 5; + PDataType baseType = PInteger.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.DESC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction16() throws Exception { + Object[] o = new Object[]{1, 2, -3, 4}; + Object[] o2 = new Object[]{1, 2, -3, 4, 5}; + Object element = 5; + PDataType baseType = PInteger.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.DESC, SortOrder.DESC); + } + + @Test + public void testArrayAppendFunction17() throws Exception { + Object[] o = new Object[]{1, 2, -3, 4}; + Object[] o2 = new Object[]{1, 2, -3, 4, 5}; + Object element = 5; + PDataType baseType = PInteger.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveIntPhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.DESC); + } + + @Test + public void testArrayAppendFunction18() throws Exception { + Object[] o = new Object[]{"1 ", "2 ", "3 ", "4 "}; + Object[] o2 = new Object[]{"1", "2", "3", "4", "5"}; + Object element = "5"; + PDataType baseType = PChar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), 4, null, baseType, 1, null, expected, SortOrder.ASC, SortOrder.DESC); + } + + @Test + public void testArrayAppendFunction19() throws Exception { + Object[] o = new Object[]{"1 ", "2 ", "3 ", "4 "}; + Object[] o2 = new Object[]{"1", "2", "3", "4", "5"}; + Object element = "5"; + PDataType baseType = PChar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), 4, null, baseType, 1, null, expected, SortOrder.DESC, SortOrder.ASC); + } + + @Test + public void testArrayAppendFunction20() throws Exception { + Object[] o = new Object[]{"1 ", "2 ", "3 ", "4 "}; + Object[] o2 = new Object[]{"1", "2", "3", "4", "5"}; + Object element = "5"; + PDataType baseType = PChar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), 4, null, baseType, 1, null, expected, SortOrder.DESC, SortOrder.DESC); + } + + @Test + public void testArrayAppendFunction21() throws Exception { + Object[] o = new Object[]{4.78, 9.54, 2.34, -9.675, Double.MAX_VALUE}; + Object[] o2 = new Object[]{4.78, 9.54, 2.34, -9.675, Double.MAX_VALUE, 12.67}; + Object element = 12.67; + PDataType baseType = PDouble.INSTANCE; + + PhoenixArray arr = new PhoenixArray.PrimitiveDoublePhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray.PrimitiveDoublePhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), null, null, baseType, null, null, expected, SortOrder.ASC, SortOrder.DESC); + } + + @Test + public void testArrayAppendFunction22() throws Exception { + Object[] o = new Object[]{"1 ", "2 ", "3 ", "4 "}; + Object[] o2 = new Object[]{"1", "2", "3", "4"}; + Object element = null; + PDataType baseType = PChar.INSTANCE; + + PhoenixArray arr = new PhoenixArray(baseType, o); + PhoenixArray expected = new PhoenixArray(baseType, o2); + test(arr, element, PDataType.fromTypeId(baseType.getSqlType() + PDataType.ARRAY_TYPE_BASE), 4, null, baseType, 1, null, expected, SortOrder.ASC, SortOrder.DESC); + } + +}
