Examples with GeographyValue org.voltdb.types.GeographyValue used on opensource projects

Example 21 with GeographyValue

use of org.voltdb.types.GeographyValue in project voltdb by VoltDB.

the class SerializationHelper method readArray.

public static Object readArray(final Class<?> type, ByteBuffer buf) throws IOException {
    final int count = type == byte.class ? buf.getInt() : buf.getShort();
    if (count < 0) {
        throw new IOException("Array length is negative " + count);
    } else if (type == byte.class) {
        if (count > (VoltType.MAX_VALUE_LENGTH)) {
            throw new IOException("Array length is greater then the max of 1 megabyte " + count);
        }
        if (count > buf.remaining()) {
            throw new IOException("Array length is greater than total buffer " + count);
        }
        final byte[] retval = new byte[count];
        buf.get(retval);
        return retval;
    } else if (type == byte[].class) {
        final byte[][] retval = new byte[count][];
        for (int i = 0; i < count; i++) {
            int size = buf.getInt();
            if (size == -1) {
                // null length prefix
                retval[i] = null;
            } else {
                retval[i] = new byte[size];
                buf.get(retval[i]);
            }
        }
        return retval;
    } else if (type == short.class) {
        final short[] retval = new short[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getShort();
        }
        return retval;
    } else if (type == int.class) {
        final int[] retval = new int[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getInt();
        }
        return retval;
    } else if (type == long.class) {
        final long[] retval = new long[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getLong();
        }
        return retval;
    } else if (type == Long.class) {
        final Long[] retval = new Long[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getLong();
        }
        return retval;
    } else if (type == String.class) {
        final String[] retval = new String[count];
        for (int i = 0; i < count; i++) {
            retval[i] = getString(buf);
        }
        return retval;
    } else if (type == double.class) {
        final double[] retval = new double[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getDouble();
        }
        return retval;
    } else if (type == Double.class) {
        final Double[] retval = new Double[count];
        for (int i = 0; i < count; i++) {
            retval[i] = buf.getDouble();
        }
        return retval;
    } else if (type == TimestampType.class) {
        final TimestampType[] retval = new TimestampType[count];
        for (int i = 0; i < count; i++) {
            retval[i] = new TimestampType(buf.getLong());
        }
        return retval;
    } else if (type == BigDecimal.class) {
        final BigDecimal[] retval = new BigDecimal[count];
        for (int i = 0; i < count; ++i) {
            retval[i] = getBigDecimal(buf);
        }
        return retval;
    } else if (type == GeographyPointValue.class) {
        final GeographyPointValue[] retval = new GeographyPointValue[count];
        for (int i = 0; i < count; ++i) {
            retval[i] = GeographyPointValue.unflattenFromBuffer(buf);
        }
        return retval;
    } else if (type == GeographyValue.class) {
        final GeographyValue[] retval = new GeographyValue[count];
        for (int i = 0; i < count; ++i) {
            // length prefix
            int len = buf.getInt();
            if (len == VoltType.NULL_STRING_LENGTH) {
                retval[i] = null;
            } else {
                retval[i] = GeographyValue.unflattenFromBuffer(buf);
            }
        }
        return retval;
    } else if (type == VoltTable.class) {
        final VoltTable[] retval = new VoltTable[count];
        for (int i = 0; i < count; ++i) {
            retval[i] = PrivateVoltTableFactory.createVoltTableFromSharedBuffer(buf.slice());
            buf.position(buf.position() + retval[i].getSerializedSize());
        }
        return retval;
    } else {
        throw new RuntimeException("SerializationHelper.readArray called with unhandled type: " + type.getName());
    }
}

Example 22 with GeographyValue

use of org.voltdb.types.GeographyValue in project voltdb by VoltDB.

the class PolygonFactory method CreateStar.

/**
     * Create a star-shaped polygon with an optional hole.  This polygon will have
     * numPointsInStar outer points, and numPointsInStar inner points.  For each
     * outer point, OP, distance(center, OP) = distance(center, firstVertex).  For
     * each inner point, IP, distance(center, IP) = ratioOfPointLength*distance(center, firstVertex).
     *
     * If sizeOfHole is positive, then there is a hole with inner and outer vertices, as
     * with the exterior shell.  For each hole exterior point, HEP,
     *     distance(center, HEP) = sizeOfHole*distance(center, firstVertex).  For each
     * hole interior point, HIP,
     *     distance(center, HIP) = sizeOfHole*rationOfPointLength*distance(center, firstVertex).
     * So, the hole is equal to the exterior shell scaled by the number sizeOfHole.
     *
     * Note that this polygon will be symmetric around any line through the center and
     * an outer or inner point.  Consequently, the centroid of the generated polygon
     * must be the center.
     *
     * @param center The center of the polygon.
     * @param firstVertex The first vertex.
     * @param numPointsInStar The number of exterior points in the star.
     * @param ratioOfPointLength The outer/inner scale factor.  This must be in the range (0,1].
     * @param sizeOfHole The scale factor for the hole.  This must be in the range [0,1).
     * @return
     * @throws IllegalArgumentException
     */
public static GeographyValue CreateStar(GeographyPointValue center, GeographyPointValue firstVertex, int numPointsInStar, // pass in 1.0 for a polygon with twice the number of vertices, or .1 for a very jagged star
double ratioOfPointLength, double sizeOfHole) throws IllegalArgumentException {
    // I don't think a 1 or 2 pointed star is possible.
    if (numPointsInStar < 3) {
        throw new IllegalArgumentException("Star polygons must have 3 or more points.");
    }
    if (sizeOfHole < 0 || 1.0 <= sizeOfHole) {
        throw new IllegalArgumentException("Star polygon hole size must be in the range [0.0, 1.0)");
    }
    if (ratioOfPointLength <= 0 || 1.0 < ratioOfPointLength) {
        throw new IllegalArgumentException("Star polygon external/internal radius ration must be in the range (0.0, 1.0]");
    }
    // We will add the nth point at angle n*phi.  We want to
    // add points in a counter clockwise order, so phi must be
    // a positive angle.  We will have twice as many vertices
    // as points.
    double phi = 360.0 / (2 * numPointsInStar);
    GeographyPointValue innerFirstVertex = firstVertex.scale(center, ratioOfPointLength);
    GeographyPointValue holeFirstVertex = null;
    GeographyPointValue innerHoleFirstVertex = null;
    // Calculate hole radii.
    if (sizeOfHole > 0) {
        holeFirstVertex = firstVertex.scale(center, sizeOfHole);
        innerHoleFirstVertex = firstVertex.scale(center, sizeOfHole * ratioOfPointLength);
    }
    // The outer and inner radii go here. We will
    // index into this array using the last bit of
    // an integer loop index.
    GeographyPointValue[] firstVertices = { firstVertex, innerFirstVertex };
    // We use the same trick here.
    GeographyPointValue[] holeFirstVertices = { holeFirstVertex, innerHoleFirstVertex };
    //
    // We have to add all shells in counter clockwise order, and all
    // holes in clockwise order.  This amounts to rotating the shell
    // generator vector by phi and the hole generator vector by -phi.
    //
    List<GeographyPointValue> outerLoop = new ArrayList<GeographyPointValue>();
    List<GeographyPointValue> holeLoop = null;
    if (sizeOfHole > 0) {
        holeLoop = new ArrayList<GeographyPointValue>();
    }
    for (int idx = 0; idx < 2 * numPointsInStar; idx += 1) {
        GeographyPointValue vert = null;
        GeographyPointValue holeVert = null;
        // Even vertices are the points.
        // Odd vertices are the valleys, if that's the right
        // term.
        vert = firstVertices[idx % 2];
        holeVert = holeFirstVertices[idx % 2];
        outerLoop.add(vert.rotate(idx * phi, center));
        if (sizeOfHole > 0) {
            holeLoop.add(holeVert.rotate(-(idx * phi), center));
        }
    }
    outerLoop.add(outerLoop.get(0));
    if (sizeOfHole > 0) {
        holeLoop.add(holeLoop.get(0));
    }
    List<List<GeographyPointValue>> loops = new ArrayList<List<GeographyPointValue>>();
    loops.add(outerLoop);
    if (sizeOfHole > 0) {
        loops.add(holeLoop);
    }
    return new GeographyValue(loops);
}

Example 23 with GeographyValue

use of org.voltdb.types.GeographyValue in project voltdb by VoltDB.

the class VoltTableUtil method toCSVWriter.

public static void toCSVWriter(CSVWriter csv, VoltTable vt, List<VoltType> columnTypes) throws IOException {
    final SimpleDateFormat sdf = m_sdf.get();
    String[] fields = new String[vt.getColumnCount()];
    while (vt.advanceRow()) {
        for (int ii = 0; ii < vt.getColumnCount(); ii++) {
            final VoltType type = columnTypes.get(ii);
            if (type == VoltType.BIGINT || type == VoltType.INTEGER || type == VoltType.SMALLINT || type == VoltType.TINYINT) {
                final long value = vt.getLong(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = Long.toString(value);
                }
            } else if (type == VoltType.FLOAT) {
                final double value = vt.getDouble(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = Double.toString(value);
                }
            } else if (type == VoltType.DECIMAL) {
                final BigDecimal bd = vt.getDecimalAsBigDecimal(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = bd.toString();
                }
            } else if (type == VoltType.STRING) {
                final String str = vt.getString(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = str;
                }
            } else if (type == VoltType.TIMESTAMP) {
                final TimestampType timestamp = vt.getTimestampAsTimestamp(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = sdf.format(timestamp.asApproximateJavaDate());
                    fields[ii] += String.format("%03d", timestamp.getUSec());
                }
            } else if (type == VoltType.VARBINARY) {
                byte[] bytes = vt.getVarbinary(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = Encoder.hexEncode(bytes);
                }
            } else if (type == VoltType.GEOGRAPHY_POINT) {
                final GeographyPointValue pt = vt.getGeographyPointValue(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = pt.toString();
                }
            } else if (type == VoltType.GEOGRAPHY) {
                final GeographyValue gv = vt.getGeographyValue(ii);
                if (vt.wasNull()) {
                    fields[ii] = Constants.CSV_NULL;
                } else {
                    fields[ii] = gv.toString();
                }
            }
        }
        csv.writeNext(fields);
    }
    csv.flush();
}

Example 24 with GeographyValue

use of org.voltdb.types.GeographyValue in project voltdb by VoltDB.

the class TestVoltTable method testFormattedString.

public void testFormattedString() throws JSONException, IOException {
    // Set the default timezone since we're using a timestamp type.  Eliminate test flakeyness.
    VoltDB.setDefaultTimezone();
    VoltTable table = new VoltTable(new ColumnInfo("tinyint", VoltType.TINYINT), new ColumnInfo("smallint", VoltType.SMALLINT), new ColumnInfo("integer", VoltType.INTEGER), new ColumnInfo("bigint", VoltType.BIGINT), new ColumnInfo("float", VoltType.FLOAT), new ColumnInfo("string", VoltType.STRING), new ColumnInfo("varbinary", VoltType.VARBINARY), new ColumnInfo("timestamp", VoltType.TIMESTAMP), new ColumnInfo("decimal", VoltType.DECIMAL));
    // add a row of nulls the hard way
    table.addRow(VoltType.NULL_TINYINT, VoltType.NULL_SMALLINT, VoltType.NULL_INTEGER, VoltType.NULL_BIGINT, VoltType.NULL_FLOAT, VoltType.NULL_STRING_OR_VARBINARY, VoltType.NULL_STRING_OR_VARBINARY, VoltType.NULL_TIMESTAMP, VoltType.NULL_DECIMAL);
    // add a row of nulls the easy way
    table.addRow(null, null, null, null, null, null, null, null, null);
    // add a row of actual data.  Hard-code the timestamp so that we can compare deterministically
    table.addRow(123, 12345, 1234567, 12345678901L, 1.234567, "aabbcc", new byte[] { 10, 26, 10 }, new TimestampType(99), new BigDecimal("123.45"));
    String formattedOutput = table.toFormattedString();
    String expectedOutput = "tinyint  smallint  integer  bigint       float     string  varbinary  timestamp                   decimal          \n" + "-------- --------- -------- ------------ --------- ------- ---------- --------------------------- -----------------\n" + "    NULL      NULL     NULL         NULL      NULL NULL    NULL       NULL                                     NULL\n" + "    NULL      NULL     NULL         NULL      NULL NULL    NULL       NULL                                     NULL\n" + "     123     12345  1234567  12345678901  1.234567 aabbcc  0A1A0A     1970-01-01 00:00:00.000099   123.450000000000\n";
    assertExpectedOutput(expectedOutput, formattedOutput);
    // fetch formatted output without column names
    formattedOutput = table.toFormattedString(false);
    expectedOutput = "    NULL      NULL     NULL         NULL      NULL NULL    NULL       NULL                                     NULL\n" + "    NULL      NULL     NULL         NULL      NULL NULL    NULL       NULL                                     NULL\n" + "     123     12345  1234567  12345678901  1.234567 aabbcc  0A1A0A     1970-01-01 00:00:00.000099   123.450000000000\n";
    assertExpectedOutput(expectedOutput, formattedOutput);
    table = new VoltTable(new ColumnInfo("bigint", VoltType.BIGINT), new ColumnInfo("geography", VoltType.GEOGRAPHY), new ColumnInfo("geography_point", VoltType.GEOGRAPHY_POINT), new ColumnInfo("timestamp", VoltType.TIMESTAMP));
    table.addRow(VoltType.NULL_BIGINT, VoltType.NULL_GEOGRAPHY, VoltType.NULL_POINT, VoltType.NULL_TIMESTAMP);
    table.addRow(null, null, null, null);
    table.addRow(123456789, new GeographyValue("POLYGON (( 1.1  9.9, " + "-9.1  9.9, " + "-9.1 -9.9, " + " 9.1 -9.9, " + " 1.1  9.9))"), new GeographyPointValue(-179.0, -89.9), new TimestampType(-1));
    formattedOutput = table.toFormattedString();
    expectedOutput = "bigint     geography                                                    geography_point       timestamp                  \n" + "---------- ------------------------------------------------------------ --------------------- ---------------------------\n" + "      NULL NULL                                                         NULL                  NULL                       \n" + "      NULL NULL                                                         NULL                  NULL                       \n" + " 123456789 POLYGON ((1.1 9.9, -9.1 9.9, -9.1 -9.9, 9.1 -9.9, 1.1 9.9))  POINT (-179.0 -89.9)  1969-12-31 23:59:59.999999 \n";
    assertExpectedOutput(expectedOutput, formattedOutput);
    // row with a polygon that max's output column width for geopgraphy column
    table.addRow(1234567890, new GeographyValue("POLYGON (( 179.1  89.9, " + "-179.1  89.9, " + "-179.1 -89.9, " + " 179.1 -89.9, " + " 179.1  89.9))"), new GeographyPointValue(-179.0, -89.9), new TimestampType(0));
    formattedOutput = table.toFormattedString();
    expectedOutput = "bigint      geography                                                                   geography_point       timestamp                  \n" + "----------- --------------------------------------------------------------------------- --------------------- ---------------------------\n" + "       NULL NULL                                                                        NULL                  NULL                       \n" + "       NULL NULL                                                                        NULL                  NULL                       \n" + "  123456789 POLYGON ((1.1 9.9, -9.1 9.9, -9.1 -9.9, 9.1 -9.9, 1.1 9.9))                 POINT (-179.0 -89.9)  1969-12-31 23:59:59.999999 \n" + " 1234567890 POLYGON ((179.1 89.9, -179.1 89.9, -179.1 -89.9, 179.1 -89.9, 179.1 89.9))  POINT (-179.0 -89.9)  1970-01-01 00:00:00.000000 \n";
    assertExpectedOutput(expectedOutput, formattedOutput);
    // row with a polygon that goes beyond max aligned display limit for polygon. This will result in
    // other columns following to appear further away from their original column
    table.addRow(12345678901L, new GeographyValue("POLYGON (( 179.12  89.9, " + "-179.12  89.9, " + "-179.1  -89.9, " + " 179.1  -89.9, " + "   0     0," + "  1.123  1.11," + " 179.12  89.9))"), new GeographyPointValue(0, 0), new TimestampType(99));
    formattedOutput = table.toFormattedString();
    expectedOutput = "bigint       geography                                                                   geography_point       timestamp                  \n" + "------------ --------------------------------------------------------------------------- --------------------- ---------------------------\n" + "        NULL NULL                                                                        NULL                  NULL                       \n" + "        NULL NULL                                                                        NULL                  NULL                       \n" + "   123456789 POLYGON ((1.1 9.9, -9.1 9.9, -9.1 -9.9, 9.1 -9.9, 1.1 9.9))                 POINT (-179.0 -89.9)  1969-12-31 23:59:59.999999 \n" + "  1234567890 POLYGON ((179.1 89.9, -179.1 89.9, -179.1 -89.9, 179.1 -89.9, 179.1 89.9))  POINT (-179.0 -89.9)  1970-01-01 00:00:00.000000 \n" + " 12345678901 POLYGON ((179.12 89.9, -179.12 89.9, -179.1 -89.9, 179.1 -89.9, 0.0 0.0, 1.123 1.11, 179.12 89.9)) POINT (0.0 0.0)       1970-01-01 00:00:00.000099 \n";
    assertExpectedOutput(expectedOutput, formattedOutput);
    // test the final one without column names
    formattedOutput = table.toFormattedString(false);
    expectedOutput = "        NULL NULL                                                                        NULL                  NULL                       \n" + "        NULL NULL                                                                        NULL                  NULL                       \n" + "   123456789 POLYGON ((1.1 9.9, -9.1 9.9, -9.1 -9.9, 9.1 -9.9, 1.1 9.9))                 POINT (-179.0 -89.9)  1969-12-31 23:59:59.999999 \n" + "  1234567890 POLYGON ((179.1 89.9, -179.1 89.9, -179.1 -89.9, 179.1 -89.9, 179.1 89.9))  POINT (-179.0 -89.9)  1970-01-01 00:00:00.000000 \n" + " 12345678901 POLYGON ((179.12 89.9, -179.12 89.9, -179.1 -89.9, 179.1 -89.9, 0.0 0.0, 1.123 1.11, 179.12 89.9)) POINT (0.0 0.0)       1970-01-01 00:00:00.000099 \n";
    assertExpectedOutput(expectedOutput, formattedOutput);
}

Example 25 with GeographyValue

use of org.voltdb.types.GeographyValue in project voltdb by VoltDB.

the class TestGeographyValueQueries method checkOnePolygonParams.

private void checkOnePolygonParams(long id, String wkt, String label, String tbl, Client client) throws IOException, ProcCallException {
    GeographyValue gv = new GeographyValue(wkt);
    assertEquals(wkt, gv.toString());
    VoltTable vt = client.callProcedure(tbl + ".Insert", id, label, gv).getResults()[0];
    validateTableOfScalarLongs(vt, new long[] { 1 });
    vt = client.callProcedure("@AdHoc", "select * from " + tbl + " where pk = " + id).getResults()[0];
    assertTrue(vt.advanceRow());
    assertEquals(id, vt.getLong(0));
    assertEquals(label, vt.getString(1));
    assertEquals(wkt, vt.getGeographyValue(2).toString());
    assertFalse(vt.advanceRow());
}