MessageFieldArgument.java

  1. /*
  2.  * Copyright 2018-2019 Providence Authors
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements. See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership. The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License. You may obtain a copy of the License at
  11.  *
  12.  *   http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing,
  15.  * software distributed under the License is distributed on an
  16.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17.  * KIND, either express or implied. See the License for the
  18.  * specific language governing permissions and limitations
  19.  * under the License.
  20.  */
  21. package net.morimekta.providence.jdbi.v2;

  23. import net.morimekta.providence.PEnumValue;
  24. import net.morimekta.providence.PMessage;
  25. import net.morimekta.providence.PMessageOrBuilder;
  26. import net.morimekta.providence.PType;
  27. import net.morimekta.providence.descriptor.PField;
  28. import net.morimekta.providence.serializer.BinarySerializer;
  29. import net.morimekta.providence.serializer.JsonSerializer;
  30. import net.morimekta.util.Binary;
  31. import org.skife.jdbi.v2.StatementContext;
  32. import org.skife.jdbi.v2.tweak.Argument;

  34. import javax.annotation.Nonnull;
  35. import java.io.ByteArrayInputStream;
  36. import java.io.ByteArrayOutputStream;
  37. import java.io.IOException;
  38. import java.io.PrintWriter;
  39. import java.io.StringReader;
  40. import java.io.StringWriter;
  41. import java.sql.Date;
  42. import java.sql.PreparedStatement;
  43. import java.sql.SQLDataException;
  44. import java.sql.SQLException;
  45. import java.sql.Timestamp;
  46. import java.sql.Types;
  47. import java.util.Calendar;
  48. import java.util.Objects;
  49. import java.util.TimeZone;

  51. /**
  52.  * Smart mapping of message fields to SQL bound argument. It will
  53.  * map the type to whichever type is default or selected (if supported)
  54.  * for most field types.
  55.  *
  56.  * @param <M> The message type.
  57.  */
  58. public class MessageFieldArgument<M extends PMessage<M>> implements Argument {
  59.     private static final BinarySerializer BINARY = new BinarySerializer();
  60.     private static final JsonSerializer   JSON   = new JsonSerializer().named();
  61.     private static final Calendar         UTC    = Calendar.getInstance(TimeZone.getTimeZone("UTC"));

  63.     private final PMessageOrBuilder<M> message;
  64.     private final PField<M>            field;
  65.     private final int                  type;

  67.     /**
  68.      * Create a message field argument.
  69.      *
  70.      * @param message The message to get the field from.
  71.      * @param field The field to select.
  72.      */
  73.     public MessageFieldArgument(@Nonnull PMessageOrBuilder<M> message, @Nonnull PField<M> field) {
  74.         this(message, field, getDefaultColumnType(field));
  75.     }

  77.     /**
  78.      * Create a message field argument.
  79.      *
  80.      * @param message The message to get the field from.
  81.      * @param field The field to select.
  82.      * @param type The SQL type. See {@link Types}.
  83.      */
  84.     public MessageFieldArgument(@Nonnull PMessageOrBuilder<M> message, @Nonnull PField<M> field, int type) {
  85.         this.message = message;
  86.         this.field = field;
  87.         this.type = type;
  88.     }

  90.     @Override
  91.     public String toString() {
  92.         if (message.has(field)) {
  93.             if (field.getType() == PType.STRING) {
  94.                 return "'" + message.get(field) + "'";
  95.             } else if (field.getType() == PType.BINARY) {
  96.                 Binary binary = message.get(field);
  97.                 return binary.toHexString();
  98.             } else if (field.getType() == PType.MESSAGE) {
  99.                 return ((PMessage) message.get(field)).asString();
  100.             }
  101.             return String.valueOf((Object) message.get(field));
  102.         }

  104.         return "null";
  105.     }

  107.     @Override
  108.     public boolean equals(Object o) {
  109.         if (o == this) return true;
  110.         if (!(o instanceof MessageFieldArgument)) return false;
  111.         MessageFieldArgument other = (MessageFieldArgument) o;
  112.         return Objects.equals(message, other.message) &&
  113.                 Objects.equals(field, other.field) &&
  114.                 type == other.type;
  115.     }

  117.     @Override
  118.     public int hashCode() {
  119.         return Objects.hash(getClass(), message, field, type);
  120.     }

  122.     @Override
  123.     @SuppressWarnings("unchecked")
  124.     public void apply(int position, PreparedStatement statement, StatementContext ctx) throws SQLException {
  125.         if (message.has(field)) {
  126.             switch (field.getType()) {
  127.                 case BOOL: {
  128.                     boolean value = message.get(field);
  129.                     if (type == Types.BOOLEAN || type == Types.BIT) {
  130.                         statement.setBoolean(position, value);
  131.                     } else {
  132.                         statement.setInt(position, value ? 1 : 0);
  133.                     }
  134.                     break;
  135.                 }
  136.                 case BYTE: {
  137.                     statement.setByte(position, message.get(field));
  138.                     break;
  139.                 }
  140.                 case I16: {
  141.                     statement.setShort(position, message.get(field));
  142.                     break;
  143.                 }
  144.                 case I32: {
  145.                     if (type == Types.TIMESTAMP || type == Types.TIMESTAMP_WITH_TIMEZONE) {
  146.                         Timestamp timestamp = new Timestamp(1000L * (int) message.get(field));
  147.                         statement.setTimestamp(position, timestamp, UTC);
  148.                     } else if (type == Types.DATE) {
  149.                         Date date = new Date(1000L * (int) message.get(field));
  150.                         statement.setDate(position, date, UTC);
  151.                     } else {
  152.                         statement.setInt(position, message.get(field));
  153.                     }
  154.                     break;
  155.                 }
  156.                 case I64: {
  157.                     if (type == Types.TIMESTAMP || type == Types.TIMESTAMP_WITH_TIMEZONE) {
  158.                         Timestamp timestamp = new Timestamp(message.get(field));
  159.                         statement.setTimestamp(position, timestamp, UTC);
  160.                     } else if (type == Types.DATE) {
  161.                         Date date = new Date(message.get(field));
  162.                         statement.setDate(position, date, UTC);
  163.                     } else {
  164.                         statement.setLong(position, message.get(field));
  165.                     }
  166.                     break;
  167.                 }
  168.                 case DOUBLE: {
  169.                     statement.setDouble(position, message.get(field));
  170.                     break;
  171.                 }
  172.                 case STRING: {
  173.                     switch (type) {
  174.                         case Types.CLOB:
  175.                         case Types.NCLOB: {
  176.                             StringReader reader = new StringReader(message.get(field));
  177.                             statement.setClob(position, reader);
  178.                             break;
  179.                         }
  180.                         default: {
  181.                             statement.setString(position, message.get(field));
  182.                             break;
  183.                         }
  184.                     }
  185.                     break;
  186.                 }
  187.                 case BINARY: {
  188.                     Binary binary = message.get(field);
  189.                     switch (type) {
  190.                         case Types.BINARY:
  191.                         case Types.VARBINARY: {
  192.                             statement.setBytes(position, binary.get());
  193.                             break;
  194.                         }
  195.                         case Types.LONGVARBINARY: {
  196.                             statement.setBinaryStream(position, binary.getInputStream());
  197.                             break;
  198.                         }
  199.                         case Types.BLOB: {
  200.                             statement.setBlob(position, binary.getInputStream());
  201.                             break;
  202.                         }
  203.                         case Types.CHAR:
  204.                         case Types.VARCHAR:
  205.                         case Types.LONGVARCHAR:
  206.                         case Types.NCHAR:
  207.                         case Types.NVARCHAR: {
  208.                             statement.setString(position, binary.toBase64());
  209.                             break;
  210.                         }
  211.                         default:
  212.                             throw new SQLDataException("Unknown binary field type: " + type + " for " + field);
  213.                     }
  214.                     break;
  215.                 }
  216.                 case ENUM: {
  217.                     PEnumValue value = message.get(field);
  218.                     statement.setInt(position, value.asInteger());
  219.                     break;
  220.                 }
  221.                 case MESSAGE: {
  222.                     PMessage value = message.get(field);
  223.                     switch (type) {
  224.                         case Types.BINARY:
  225.                         case Types.LONGVARBINARY:
  226.                         case Types.VARBINARY: {
  227.                             ByteArrayOutputStream out = new ByteArrayOutputStream();
  228.                             try {
  229.                                 BINARY.serialize(out, value);
  230.                                 statement.setBytes(position, out.toByteArray());
  231.                             } catch (IOException e) {
  232.                                 throw new SQLDataException(e.getMessage(), e);
  233.                             }
  234.                             break;
  235.                         }
  236.                         case Types.BLOB: {
  237.                             ByteArrayOutputStream out = new ByteArrayOutputStream();
  238.                             try {
  239.                                 BINARY.serialize(out, value);
  240.                                 statement.setBlob(position, new ByteArrayInputStream(out.toByteArray()));
  241.                             } catch (IOException e) {
  242.                                 throw new SQLDataException(e.getMessage(), e);
  243.                             }
  244.                             break;
  245.                         }
  246.                         case Types.CHAR:
  247.                         case Types.VARCHAR:
  248.                         case Types.LONGVARCHAR:
  249.                         case Types.NCHAR:
  250.                         case Types.NVARCHAR: {
  251.                             StringWriter writer = new StringWriter();
  252.                             try {
  253.                                 JSON.serialize(new PrintWriter(writer), value);
  254.                                 statement.setString(position, writer.getBuffer().toString());
  255.                             } catch (IOException e) {
  256.                                 throw new SQLDataException(e.getMessage(), e);
  257.                             }
  258.                             break;
  259.                         }
  260.                         case Types.NCLOB:
  261.                         case Types.CLOB: {
  262.                             StringWriter writer = new StringWriter();
  263.                             try {
  264.                                 JSON.serialize(new PrintWriter(writer), value);
  265.                                 statement.setClob(position, new StringReader(writer.getBuffer().toString()));
  266.                             } catch (IOException e) {
  267.                                 throw new SQLDataException(e.getMessage(), e);
  268.                             }
  269.                             break;
  270.                         }
  271.                         default:
  272.                             throw new SQLDataException("Unknown message field type: " + type + " for " + field);
  273.                     }
  274.                     break;
  275.                 }
  276.                 default:
  277.                     throw new SQLDataException("Unhandled field type in SQL: " + field);
  278.             }
  279.         } else {
  280.             statement.setNull(position, type);
  281.         }
  282.     }

  284.     static int getDefaultColumnType(PField field) {
  285.         switch (field.getType()) {
  286.             case BOOL: return Types.BIT;
  287.             case BYTE: return Types.TINYINT;
  288.             case I16: return Types.SMALLINT;
  289.             case I32: return Types.INTEGER;
  290.             case I64: return Types.BIGINT;
  291.             case DOUBLE: return Types.DOUBLE;
  292.             case STRING: return Types.VARCHAR;
  293.             case BINARY: return Types.VARBINARY;
  294.             case ENUM: return Types.INTEGER;
  295.             case MESSAGE: return Types.VARCHAR;  // JSON string.
  296.             default: {
  297.                 throw new IllegalArgumentException("No default column type for " + field.toString());
  298.             }
  299.         }
  300.     }
  301. }
Created with JaCoCo 0.8.5.201910111838