Examples with Column com.scalar.db.io.Column used on opensource projects

Search in sources :

Example 6 with Column

use of com.scalar.db.io.Column in project scalardb by scalar-labs.

the class QueryBuilderTest method insertQueryTest.

@ParameterizedTest
@EnumSource(RdbEngine.class)
public void insertQueryTest(RdbEngine rdbEngine) throws SQLException {
    QueryBuilder queryBuilder = new QueryBuilder(rdbEngine);
    InsertQuery query;
    PreparedStatement preparedStatement;
    Map<String, Column<?>> columns = new HashMap<>();
    columns.put("v1", TextColumn.of("v1", "v1Value"));
    columns.put("v2", TextColumn.of("v2", "v2Value"));
    columns.put("v3", TextColumn.of("v3", "v3Value"));
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.insertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value"), Optional.empty(), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql("INSERT INTO n1.t1 (p1,v1,v2,v3) VALUES (?,?,?,?)", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "p1Value");
    verify(preparedStatement).setString(2, "v1Value");
    verify(preparedStatement).setString(3, "v2Value");
    verify(preparedStatement).setString(4, "v3Value");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.insertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql("INSERT INTO n1.t1 (p1,c1,v1,v2,v3) VALUES (?,?,?,?,?)", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "p1Value");
    verify(preparedStatement).setString(2, "c1Value");
    verify(preparedStatement).setString(3, "v1Value");
    verify(preparedStatement).setString(4, "v2Value");
    verify(preparedStatement).setString(5, "v3Value");
    columns.put("v4", TextColumn.of("v4", "v4Value"));
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.insertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value", "p2", "p2Value"), Optional.of(new Key("c1", "c1Value", "c2", "c2Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql("INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4) VALUES (?,?,?,?,?,?,?,?)", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "p1Value");
    verify(preparedStatement).setString(2, "p2Value");
    verify(preparedStatement).setString(3, "c1Value");
    verify(preparedStatement).setString(4, "c2Value");
    verify(preparedStatement).setString(5, "v1Value");
    verify(preparedStatement).setString(6, "v2Value");
    verify(preparedStatement).setString(7, "v3Value");
    verify(preparedStatement).setString(8, "v4Value");
    columns.put("v5", TextColumn.ofNull("v5"));
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.insertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value", "p2", "p2Value"), Optional.of(new Key("c1", "c1Value", "c2", "c2Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql("INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4,v5) VALUES (?,?,?,?,?,?,?,?,?)", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "p1Value");
    verify(preparedStatement).setString(2, "p2Value");
    verify(preparedStatement).setString(3, "c1Value");
    verify(preparedStatement).setString(4, "c2Value");
    verify(preparedStatement).setString(5, "v1Value");
    verify(preparedStatement).setString(6, "v2Value");
    verify(preparedStatement).setString(7, "v3Value");
    verify(preparedStatement).setString(8, "v4Value");
    verify(preparedStatement).setNull(9, Types.VARCHAR);
}
Also used : TextColumn(com.scalar.db.io.TextColumn) Column(com.scalar.db.io.Column) HashMap(java.util.HashMap) PreparedStatement(java.sql.PreparedStatement) Key(com.scalar.db.io.Key) EnumSource(org.junit.jupiter.params.provider.EnumSource) ParameterizedTest(org.junit.jupiter.params.ParameterizedTest)

Example 7 with Column

use of com.scalar.db.io.Column in project scalardb by scalar-labs.

the class QueryBuilderTest method upsertQueryTest.

@ParameterizedTest
@EnumSource(RdbEngine.class)
public void upsertQueryTest(RdbEngine rdbEngine) throws SQLException {
    QueryBuilder queryBuilder = new QueryBuilder(rdbEngine);
    String expectedQuery;
    UpsertQuery query;
    PreparedStatement preparedStatement;
    Map<String, Column<?>> columns = new HashMap<>();
    columns.put("v1", TextColumn.of("v1", "v1Value"));
    columns.put("v2", TextColumn.of("v2", "v2Value"));
    columns.put("v3", TextColumn.of("v3", "v3Value"));
    preparedStatement = mock(PreparedStatement.class);
    switch(rdbEngine) {
        case MYSQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,v1,v2,v3) VALUES (?,?,?,?)" + " ON DUPLICATE KEY UPDATE v1=?,v2=?,v3=?";
            break;
        case POSTGRESQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,v1,v2,v3) VALUES (?,?,?,?) " + "ON CONFLICT (p1) DO UPDATE SET v1=?,v2=?,v3=?";
            break;
        case ORACLE:
            expectedQuery = "MERGE INTO n1.t1 t1 USING (SELECT ? p1 FROM DUAL) t2 ON (t1.p1=t2.p1) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=? " + "WHEN NOT MATCHED THEN INSERT (p1,v1,v2,v3) VALUES (?,?,?,?)";
            break;
        case SQL_SERVER:
        default:
            expectedQuery = "MERGE n1.t1 t1 USING (SELECT ? p1) t2 ON (t1.p1=t2.p1) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=? " + "WHEN NOT MATCHED THEN INSERT (p1,v1,v2,v3) VALUES (?,?,?,?);";
            break;
    }
    query = queryBuilder.upsertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value"), Optional.empty(), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql(expectedQuery, rdbEngine));
    query.bind(preparedStatement);
    switch(rdbEngine) {
        case MYSQL:
        case POSTGRESQL:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "v1Value");
            verify(preparedStatement).setString(3, "v2Value");
            verify(preparedStatement).setString(4, "v3Value");
            verify(preparedStatement).setString(5, "v1Value");
            verify(preparedStatement).setString(6, "v2Value");
            verify(preparedStatement).setString(7, "v3Value");
            break;
        case ORACLE:
        case SQL_SERVER:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "v1Value");
            verify(preparedStatement).setString(3, "v2Value");
            verify(preparedStatement).setString(4, "v3Value");
            verify(preparedStatement).setString(5, "p1Value");
            verify(preparedStatement).setString(6, "v1Value");
            verify(preparedStatement).setString(7, "v2Value");
            verify(preparedStatement).setString(8, "v3Value");
            break;
    }
    preparedStatement = mock(PreparedStatement.class);
    switch(rdbEngine) {
        case MYSQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,c1,v1,v2,v3) VALUES (?,?,?,?,?)" + " ON DUPLICATE KEY UPDATE v1=?,v2=?,v3=?";
            break;
        case POSTGRESQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,c1,v1,v2,v3) VALUES (?,?,?,?,?) " + "ON CONFLICT (p1,c1) DO UPDATE SET v1=?,v2=?,v3=?";
            break;
        case ORACLE:
            expectedQuery = "MERGE INTO n1.t1 t1 USING (SELECT ? p1,? c1 FROM DUAL) t2 " + "ON (t1.p1=t2.p1 AND t1.c1=t2.c1) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=? " + "WHEN NOT MATCHED THEN INSERT (p1,c1,v1,v2,v3) VALUES (?,?,?,?,?)";
            break;
        case SQL_SERVER:
        default:
            expectedQuery = "MERGE n1.t1 t1 USING (SELECT ? p1,? c1) t2 " + "ON (t1.p1=t2.p1 AND t1.c1=t2.c1) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=? " + "WHEN NOT MATCHED THEN INSERT (p1,c1,v1,v2,v3) VALUES (?,?,?,?,?);";
            break;
    }
    query = queryBuilder.upsertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql(expectedQuery, rdbEngine));
    query.bind(preparedStatement);
    switch(rdbEngine) {
        case MYSQL:
        case POSTGRESQL:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "c1Value");
            verify(preparedStatement).setString(3, "v1Value");
            verify(preparedStatement).setString(4, "v2Value");
            verify(preparedStatement).setString(5, "v3Value");
            verify(preparedStatement).setString(6, "v1Value");
            verify(preparedStatement).setString(7, "v2Value");
            verify(preparedStatement).setString(8, "v3Value");
            break;
        case ORACLE:
        case SQL_SERVER:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "c1Value");
            verify(preparedStatement).setString(3, "v1Value");
            verify(preparedStatement).setString(4, "v2Value");
            verify(preparedStatement).setString(5, "v3Value");
            verify(preparedStatement).setString(6, "p1Value");
            verify(preparedStatement).setString(7, "c1Value");
            verify(preparedStatement).setString(8, "v1Value");
            verify(preparedStatement).setString(9, "v2Value");
            verify(preparedStatement).setString(10, "v3Value");
            break;
    }
    columns.put("v4", TextColumn.of("v4", "v4Value"));
    preparedStatement = mock(PreparedStatement.class);
    switch(rdbEngine) {
        case MYSQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4) VALUES (?,?,?,?,?,?,?,?)" + " ON DUPLICATE KEY UPDATE v1=?,v2=?,v3=?,v4=?";
            break;
        case POSTGRESQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4) VALUES (?,?,?,?,?,?,?,?) " + "ON CONFLICT (p1,p2,c1,c2) DO UPDATE SET v1=?,v2=?,v3=?,v4=?";
            break;
        case ORACLE:
            expectedQuery = "MERGE INTO n1.t1 t1 USING (SELECT ? p1,? p2,? c1,? c2 FROM DUAL) t2 " + "ON (t1.p1=t2.p1 AND t1.p2=t2.p2 AND t1.c1=t2.c1 AND t1.c2=t2.c2) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=?,v4=? " + "WHEN NOT MATCHED THEN INSERT (p1,p2,c1,c2,v1,v2,v3,v4) " + "VALUES (?,?,?,?,?,?,?,?)";
            break;
        case SQL_SERVER:
        default:
            expectedQuery = "MERGE n1.t1 t1 USING (SELECT ? p1,? p2,? c1,? c2) t2 " + "ON (t1.p1=t2.p1 AND t1.p2=t2.p2 AND t1.c1=t2.c1 AND t1.c2=t2.c2) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=?,v4=? " + "WHEN NOT MATCHED THEN INSERT (p1,p2,c1,c2,v1,v2,v3,v4) VALUES (?,?,?,?,?,?,?,?);";
            break;
    }
    query = queryBuilder.upsertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value", "p2", "p2Value"), Optional.of(new Key("c1", "c1Value", "c2", "c2Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql(expectedQuery, rdbEngine));
    query.bind(preparedStatement);
    switch(rdbEngine) {
        case MYSQL:
        case POSTGRESQL:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "p2Value");
            verify(preparedStatement).setString(3, "c1Value");
            verify(preparedStatement).setString(4, "c2Value");
            verify(preparedStatement).setString(5, "v1Value");
            verify(preparedStatement).setString(6, "v2Value");
            verify(preparedStatement).setString(7, "v3Value");
            verify(preparedStatement).setString(8, "v4Value");
            verify(preparedStatement).setString(9, "v1Value");
            verify(preparedStatement).setString(10, "v2Value");
            verify(preparedStatement).setString(11, "v3Value");
            verify(preparedStatement).setString(12, "v4Value");
            break;
        case ORACLE:
        case SQL_SERVER:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "p2Value");
            verify(preparedStatement).setString(3, "c1Value");
            verify(preparedStatement).setString(4, "c2Value");
            verify(preparedStatement).setString(5, "v1Value");
            verify(preparedStatement).setString(6, "v2Value");
            verify(preparedStatement).setString(7, "v3Value");
            verify(preparedStatement).setString(8, "v4Value");
            verify(preparedStatement).setString(9, "p1Value");
            verify(preparedStatement).setString(10, "p2Value");
            verify(preparedStatement).setString(11, "c1Value");
            verify(preparedStatement).setString(12, "c2Value");
            verify(preparedStatement).setString(13, "v1Value");
            verify(preparedStatement).setString(14, "v2Value");
            verify(preparedStatement).setString(15, "v3Value");
            verify(preparedStatement).setString(16, "v4Value");
            break;
    }
    columns.put("v5", TextColumn.ofNull("v5"));
    preparedStatement = mock(PreparedStatement.class);
    switch(rdbEngine) {
        case MYSQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4,v5) VALUES (?,?,?,?,?,?,?,?,?)" + " ON DUPLICATE KEY UPDATE v1=?,v2=?,v3=?,v4=?,v5=?";
            break;
        case POSTGRESQL:
            expectedQuery = "INSERT INTO n1.t1 (p1,p2,c1,c2,v1,v2,v3,v4,v5) VALUES (?,?,?,?,?,?,?,?,?) " + "ON CONFLICT (p1,p2,c1,c2) DO UPDATE SET v1=?,v2=?,v3=?,v4=?,v5=?";
            break;
        case ORACLE:
            expectedQuery = "MERGE INTO n1.t1 t1 USING (SELECT ? p1,? p2,? c1,? c2 FROM DUAL) t2 " + "ON (t1.p1=t2.p1 AND t1.p2=t2.p2 AND t1.c1=t2.c1 AND t1.c2=t2.c2) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=?,v4=?,v5=? " + "WHEN NOT MATCHED THEN INSERT (p1,p2,c1,c2,v1,v2,v3,v4,v5) " + "VALUES (?,?,?,?,?,?,?,?,?)";
            break;
        case SQL_SERVER:
        default:
            expectedQuery = "MERGE n1.t1 t1 USING (SELECT ? p1,? p2,? c1,? c2) t2 " + "ON (t1.p1=t2.p1 AND t1.p2=t2.p2 AND t1.c1=t2.c1 AND t1.c2=t2.c2) " + "WHEN MATCHED THEN UPDATE SET v1=?,v2=?,v3=?,v4=?,v5=? " + "WHEN NOT MATCHED THEN INSERT (p1,p2,c1,c2,v1,v2,v3,v4,v5) " + "VALUES (?,?,?,?,?,?,?,?,?);";
            break;
    }
    query = queryBuilder.upsertInto(NAMESPACE, TABLE, TABLE_METADATA).values(new Key("p1", "p1Value", "p2", "p2Value"), Optional.of(new Key("c1", "c1Value", "c2", "c2Value")), columns).build();
    assertThat(query.sql()).isEqualTo(encloseSql(expectedQuery, rdbEngine));
    query.bind(preparedStatement);
    switch(rdbEngine) {
        case MYSQL:
        case POSTGRESQL:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "p2Value");
            verify(preparedStatement).setString(3, "c1Value");
            verify(preparedStatement).setString(4, "c2Value");
            verify(preparedStatement).setString(5, "v1Value");
            verify(preparedStatement).setString(6, "v2Value");
            verify(preparedStatement).setString(7, "v3Value");
            verify(preparedStatement).setString(8, "v4Value");
            verify(preparedStatement).setNull(9, Types.VARCHAR);
            verify(preparedStatement).setString(10, "v1Value");
            verify(preparedStatement).setString(11, "v2Value");
            verify(preparedStatement).setString(12, "v3Value");
            verify(preparedStatement).setString(13, "v4Value");
            verify(preparedStatement).setNull(14, Types.VARCHAR);
            break;
        case ORACLE:
        case SQL_SERVER:
            verify(preparedStatement).setString(1, "p1Value");
            verify(preparedStatement).setString(2, "p2Value");
            verify(preparedStatement).setString(3, "c1Value");
            verify(preparedStatement).setString(4, "c2Value");
            verify(preparedStatement).setString(5, "v1Value");
            verify(preparedStatement).setString(6, "v2Value");
            verify(preparedStatement).setString(7, "v3Value");
            verify(preparedStatement).setString(8, "v4Value");
            verify(preparedStatement).setNull(9, Types.VARCHAR);
            verify(preparedStatement).setString(10, "p1Value");
            verify(preparedStatement).setString(11, "p2Value");
            verify(preparedStatement).setString(12, "c1Value");
            verify(preparedStatement).setString(13, "c2Value");
            verify(preparedStatement).setString(14, "v1Value");
            verify(preparedStatement).setString(15, "v2Value");
            verify(preparedStatement).setString(16, "v3Value");
            verify(preparedStatement).setString(17, "v4Value");
            verify(preparedStatement).setNull(18, Types.VARCHAR);
            break;
    }
}
Also used : TextColumn(com.scalar.db.io.TextColumn) Column(com.scalar.db.io.Column) HashMap(java.util.HashMap) PreparedStatement(java.sql.PreparedStatement) Key(com.scalar.db.io.Key) EnumSource(org.junit.jupiter.params.provider.EnumSource) ParameterizedTest(org.junit.jupiter.params.ParameterizedTest)

Example 8 with Column

use of com.scalar.db.io.Column in project scalardb by scalar-labs.

the class QueryBuilderTest method updateQueryTest.

@ParameterizedTest
@EnumSource(RdbEngine.class)
public void updateQueryTest(RdbEngine rdbEngine) throws SQLException {
    QueryBuilder queryBuilder = new QueryBuilder(rdbEngine);
    UpdateQuery query;
    PreparedStatement preparedStatement;
    Map<String, Column<?>> columns = new HashMap<>();
    columns.put("v1", TextColumn.of("v1", "v1Value"));
    columns.put("v2", TextColumn.of("v2", "v2Value"));
    columns.put("v3", TextColumn.of("v3", "v3Value"));
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.empty()).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value"))).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=? AND c1=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    verify(preparedStatement).setString(5, "c1Value");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value", "p2", "p2Value"), Optional.of(new Key("c1", "c1Value", "c2", "c2Value"))).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=? AND p2=? AND c1=? AND c2=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    verify(preparedStatement).setString(5, "p2Value");
    verify(preparedStatement).setString(6, "c1Value");
    verify(preparedStatement).setString(7, "c2Value");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value")), Collections.singletonList(new ConditionalExpression("v1", new TextValue("v1ConditionValue"), Operator.EQ))).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=? AND c1=? AND v1=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    verify(preparedStatement).setString(5, "c1Value");
    verify(preparedStatement).setString(6, "v1ConditionValue");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value")), Arrays.asList(new ConditionalExpression("v1", new TextValue("v1ConditionValue"), Operator.NE), new ConditionalExpression("v2", new TextValue("v2ConditionValue"), Operator.GT), new ConditionalExpression("v3", new TextValue("v3ConditionValue"), Operator.LTE))).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=? AND c1=? AND v1<>? AND v2>? AND v3<=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    verify(preparedStatement).setString(5, "c1Value");
    verify(preparedStatement).setString(6, "v1ConditionValue");
    verify(preparedStatement).setString(7, "v2ConditionValue");
    verify(preparedStatement).setString(8, "v3ConditionValue");
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value")), Arrays.asList(ConditionBuilder.column("v1").isNullText(), ConditionBuilder.column("v2").isNotNullText())).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=? WHERE p1=? AND c1=? AND v1 IS NULL AND v2 IS NOT NULL", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setString(4, "p1Value");
    verify(preparedStatement).setString(5, "c1Value");
    columns.put("v4", TextColumn.ofNull("v4"));
    preparedStatement = mock(PreparedStatement.class);
    query = queryBuilder.update(NAMESPACE, TABLE, TABLE_METADATA).set(columns).where(new Key("p1", "p1Value"), Optional.of(new Key("c1", "c1Value"))).build();
    assertThat(query.sql()).isEqualTo(encloseSql("UPDATE n1.t1 SET v1=?,v2=?,v3=?,v4=? WHERE p1=? AND c1=?", rdbEngine));
    query.bind(preparedStatement);
    verify(preparedStatement).setString(1, "v1Value");
    verify(preparedStatement).setString(2, "v2Value");
    verify(preparedStatement).setString(3, "v3Value");
    verify(preparedStatement).setNull(4, Types.VARCHAR);
    verify(preparedStatement).setString(5, "p1Value");
    verify(preparedStatement).setString(6, "c1Value");
}
Also used : TextColumn(com.scalar.db.io.TextColumn) Column(com.scalar.db.io.Column) HashMap(java.util.HashMap) TextValue(com.scalar.db.io.TextValue) ConditionalExpression(com.scalar.db.api.ConditionalExpression) PreparedStatement(java.sql.PreparedStatement) Key(com.scalar.db.io.Key) EnumSource(org.junit.jupiter.params.provider.EnumSource) ParameterizedTest(org.junit.jupiter.params.ParameterizedTest)

Example 9 with Column

use of com.scalar.db.io.Column in project scalardb by scalar-labs.

the class TransactionResultTest method equals_ResultImplWithDifferentValuesGiven_ShouldReturnFalse.

@Test
public void equals_ResultImplWithDifferentValuesGiven_ShouldReturnFalse() {
    // Arrange
    Result r1 = new ResultImpl(ImmutableMap.<String, Column<?>>builder().put(ANY_NAME_1, TextColumn.of(ANY_NAME_1, ANY_TEXT_1)).put(ANY_NAME_2, TextColumn.of(ANY_NAME_2, ANY_TEXT_2)).put(ANY_NAME_3, IntColumn.of(ANY_NAME_3, ANY_INT_2)).put(Attribute.ID, ScalarDbUtils.toColumn(Attribute.toIdValue(ANY_ID_2))).put(Attribute.PREPARED_AT, ScalarDbUtils.toColumn(Attribute.toPreparedAtValue(ANY_TIME_3))).put(Attribute.COMMITTED_AT, ScalarDbUtils.toColumn(Attribute.toCommittedAtValue(ANY_TIME_4))).put(Attribute.STATE, ScalarDbUtils.toColumn(Attribute.toStateValue(TransactionState.COMMITTED))).put(Attribute.VERSION, ScalarDbUtils.toColumn(Attribute.toVersionValue(ANY_VERSION_2))).put(Attribute.BEFORE_PREFIX + ANY_NAME_3, IntColumn.of(Attribute.BEFORE_PREFIX + ANY_NAME_3, ANY_INT_1)).put(Attribute.BEFORE_ID, ScalarDbUtils.toColumn(Attribute.toBeforeIdValue(ANY_ID_1))).put(Attribute.BEFORE_PREPARED_AT, ScalarDbUtils.toColumn(Attribute.toBeforePreparedAtValue(ANY_TIME_1))).put(Attribute.BEFORE_COMMITTED_AT, ScalarDbUtils.toColumn(Attribute.toBeforeCommittedAtValue(ANY_TIME_2))).put(Attribute.BEFORE_STATE, ScalarDbUtils.toColumn(Attribute.toBeforeStateValue(TransactionState.COMMITTED))).put(Attribute.BEFORE_VERSION, ScalarDbUtils.toColumn(Attribute.toBeforeVersionValue(ANY_VERSION_1))).build(), TABLE_METADATA);
    Map<String, Column<?>> emptyValues = Collections.emptyMap();
    Result r2 = new TransactionResult(new ResultImpl(emptyValues, TABLE_METADATA));
    // Act Assert
    assertThat(r1.equals(r2)).isFalse();
}
Also used : IntColumn(com.scalar.db.io.IntColumn) Column(com.scalar.db.io.Column) TextColumn(com.scalar.db.io.TextColumn) ResultImpl(com.scalar.db.common.ResultImpl) Result(com.scalar.db.api.Result) Test(org.junit.jupiter.api.Test)

Example 10 with Column

use of com.scalar.db.io.Column in project scalardb by scalar-labs.

the class TransactionResultTest method equals_ResultImplWithSameValuesGiven_ShouldReturnTrue.

@Test
public void equals_ResultImplWithSameValuesGiven_ShouldReturnTrue() {
    // Arrange
    Result r1 = new ResultImpl(ImmutableMap.<String, Column<?>>builder().put(ANY_NAME_1, TextColumn.of(ANY_NAME_1, ANY_TEXT_1)).put(ANY_NAME_2, TextColumn.of(ANY_NAME_2, ANY_TEXT_2)).put(ANY_NAME_3, IntColumn.of(ANY_NAME_3, ANY_INT_2)).put(Attribute.ID, ScalarDbUtils.toColumn(Attribute.toIdValue(ANY_ID_2))).put(Attribute.PREPARED_AT, ScalarDbUtils.toColumn(Attribute.toPreparedAtValue(ANY_TIME_3))).put(Attribute.COMMITTED_AT, ScalarDbUtils.toColumn(Attribute.toCommittedAtValue(ANY_TIME_4))).put(Attribute.STATE, ScalarDbUtils.toColumn(Attribute.toStateValue(TransactionState.COMMITTED))).put(Attribute.VERSION, ScalarDbUtils.toColumn(Attribute.toVersionValue(ANY_VERSION_2))).put(Attribute.BEFORE_PREFIX + ANY_NAME_3, IntColumn.of(Attribute.BEFORE_PREFIX + ANY_NAME_3, ANY_INT_1)).put(Attribute.BEFORE_ID, ScalarDbUtils.toColumn(Attribute.toBeforeIdValue(ANY_ID_1))).put(Attribute.BEFORE_PREPARED_AT, ScalarDbUtils.toColumn(Attribute.toBeforePreparedAtValue(ANY_TIME_1))).put(Attribute.BEFORE_COMMITTED_AT, ScalarDbUtils.toColumn(Attribute.toBeforeCommittedAtValue(ANY_TIME_2))).put(Attribute.BEFORE_STATE, ScalarDbUtils.toColumn(Attribute.toBeforeStateValue(TransactionState.COMMITTED))).put(Attribute.BEFORE_VERSION, ScalarDbUtils.toColumn(Attribute.toBeforeVersionValue(ANY_VERSION_1))).build(), TABLE_METADATA);
    Result r2 = new TransactionResult(r1);
    // Act Assert
    assertThat(r1.equals(r2)).isTrue();
}
Also used : IntColumn(com.scalar.db.io.IntColumn) Column(com.scalar.db.io.Column) TextColumn(com.scalar.db.io.TextColumn) ResultImpl(com.scalar.db.common.ResultImpl) Result(com.scalar.db.api.Result) Test(org.junit.jupiter.api.Test)

Aggregations

Column (com.scalar.db.io.Column)12 TextColumn (com.scalar.db.io.TextColumn)11 IntColumn (com.scalar.db.io.IntColumn)7 Test (org.junit.jupiter.api.Test)7 ResultImpl (com.scalar.db.common.ResultImpl)5 Key (com.scalar.db.io.Key)5 Result (com.scalar.db.api.Result)4 BigIntColumn (com.scalar.db.io.BigIntColumn)4 BlobColumn (com.scalar.db.io.BlobColumn)4 BooleanColumn (com.scalar.db.io.BooleanColumn)4 DoubleColumn (com.scalar.db.io.DoubleColumn)4 FloatColumn (com.scalar.db.io.FloatColumn)4 HashMap (java.util.HashMap)4 TextValue (com.scalar.db.io.TextValue)3 PreparedStatement (java.sql.PreparedStatement)3 ParameterizedTest (org.junit.jupiter.params.ParameterizedTest)3 EnumSource (org.junit.jupiter.params.provider.EnumSource)3 BigIntValue (com.scalar.db.io.BigIntValue)2 BlobValue (com.scalar.db.io.BlobValue)2 BooleanValue (com.scalar.db.io.BooleanValue)2
About Me
UseOf

Java Tutorials :

Simple Java RabbitMQ Example with Spring
Simple Springboot JPA Eclipeslink Example
Simple SpringBoot JPA Hibernate Example
Jackson JSON @JsonIgnore and @JsonIgnoreProperties Examples
Java Infinite recursion (StackOverflowError) Jackson solutions
Simple Java Jackson Serialize Objects to JSON and convert them back To Object
ElasticSearch 5 - Upload files using Java API in binary field Example
Java JAXB marshall unmarshall Examples from String and Stream
Java 8 forEach List and Map examples
ElasticSearch 5 Java API SearchRequestBuilder examples
Java ElasticSearch 5 examples with node index and mapping - running local
Convert String to int or Integer Java 8
Java 9 in action - JShell - Ubuntu
Java - removing invalid characters from a file name
Hello world!? or Hello Tutorial