Java SQLDialect.POSTGRES屬性代碼示例

private FullTextSearch<Application> determineSearcher(SQLDialect dialect) {

        if (dialect == SQLDialect.POSTGRES) {
            return new PostgresAppSearch();
        }

        if (dialect == SQLDialect.MARIADB) {
            return new MariaAppSearch();
        }

        if (dialect.name().startsWith("SQLSERVER")) {
            return new SqlServerAppSearch();
        }

        return new UnsupportedSearcher<>(dialect);
    }
 

private FullTextSearch<OrganisationalUnit> determineSearcher(SQLDialect dialect) {

        if (dialect == SQLDialect.POSTGRES) {
            return new PostgresOrganisationalUnitSearch();
        }

        if (dialect == SQLDialect.MARIADB) {
            return new MariaOrganisationalUnitSearch();
        }

        // cannot do direct comparison as may not be present.
        if (dialect.name().equals("SQLSERVER2014")) {
            return new SqlServerOrganisationalUnitSearch();
        }

        return new UnsupportedSearcher<>(dialect);
    }
 

private FullTextSearch<ChangeInitiative> determineSearcher(SQLDialect dialect) {

        if (dialect == SQLDialect.POSTGRES) {
            return new PostgresChangeInitiativeSearch();
        }

        if (dialect == SQLDialect.MARIADB) {
            return new MariaChangeInitiativeSearch();
        }

        if (dialect.name().startsWith("SQLSERVER")) {
            return new SqlServerChangeInitiativeSearch();
        }

        return new UnsupportedSearcher<>(dialect);
    }
 

private FullTextSearch<Measurable> determineSearcher(SQLDialect dialect) {

        if (dialect == SQLDialect.POSTGRES) {
            return new PostgresMeasurableSearch();
        }

        if (dialect == SQLDialect.MARIADB) {
            return new MariaMeasurableSearch();
        }

        if (dialect.name().startsWith("SQLSERVER")) {
            return new SqlServerMeasurableSearch();
        }

        return new UnsupportedSearcher<>(dialect);
    }
 

private FullTextSearch<Person> determineSearcher(SQLDialect dialect) {

        if (dialect == SQLDialect.POSTGRES) {
            return new PostgresPersonSearch();
        }

        if (dialect == SQLDialect.MARIADB) {
            return new MariaPersonSearch();
        }

        if (dialect.name().equals("SQLSERVER2014")) {
            return new SqlServerPersonSearch();
        }

        return new UnsupportedSearcher<>(dialect);
    }
 

@Test
public void should_not_contain_where_clause_on_submissions() throws Exception {
    // given
    SubmissionListFilter filter = new SubmissionListFilter();
    filter.getStatuses().setStatuses(new ArrayList<>());
    final DSLContext create = new DefaultDSLContext(SQLDialect.POSTGRES);
    final SelectJoinStep step = create.select().from();

    // when
    SubmissionFilterAppender.appendOn(filter, step);

    // then
    assertThat("should not contain where clause on submissions",
               step.getSQL(),
               not(containsString("where 1 = 0")));
}
 

private SQLDialect detectSqlDialect(DataSource dataSource) throws SQLException {
    String databaseProductName;
    try (Connection conn = dataSource.getConnection()) {
        databaseProductName = conn.getMetaData().getDatabaseProductName();
    }

    if ("H2".equalsIgnoreCase(databaseProductName)) {
        return SQLDialect.H2;
    } else if ("MySQL".equalsIgnoreCase(databaseProductName)) {
        return SQLDialect.MARIADB;
    } else if ("PostgreSQL".equalsIgnoreCase(databaseProductName)) {
        return SQLDialect.POSTGRES;
    }
    throw new IllegalArgumentException("Unknown DB dialect: " + databaseProductName);
}
 

private SQLDialect getJooqSqlDialect() {
    switch (this.dialect) {
        case MySql:
            return SQLDialect.MYSQL;
        case Postgres:
            return SQLDialect.POSTGRES;
    }
    throw new UnsupportedOperationException();
}
 

@Parameters(name = "{0}")
public static Object[] parameters() {
	return new Object[] { new Object[] { SQLDialect.DERBY, sqlException("42802") },
			new Object[] { SQLDialect.H2, sqlException(42000) },
			new Object[] { SQLDialect.HSQLDB, sqlException(-22) },
			new Object[] { SQLDialect.MARIADB, sqlException(1054) },
			new Object[] { SQLDialect.MYSQL, sqlException(1054) },
			new Object[] { SQLDialect.POSTGRES, sqlException("03000") },
			new Object[] { SQLDialect.POSTGRES_9_3, sqlException("03000") },
			new Object[] { SQLDialect.POSTGRES_9_4, sqlException("03000") },
			new Object[] { SQLDialect.POSTGRES_9_5, sqlException("03000") } };
}
 

public static void main(String[] args) {
	SQLDialect sqlDialect = args.length == 0 ? SQLDialect.HSQLDB : SQLDialect.POSTGRES; // SQLDialect.ORACLE

	Settings settings = new Settings()
		.withRenderFormatted(true)
		.withRenderSchema(TRUE)
		.withRenderNameStyle(RenderNameStyle.UPPER);
	if (sqlDialect == SQLDialect.POSTGRES) {
		String schema1Name = args[0];
		String schema2Name = args[1];
		settings.withRenderMapping(new RenderMapping()
			.withSchemata(
				new MappedSchema().withInput(SCHEMA1.getName()).withOutput(schema1Name),
				new MappedSchema().withInput(SCHEMA2.getName()).withOutput(schema2Name)));
	}
	
	Configuration config = new DefaultConfiguration()
		.set(sqlDialect)
		.set(settings);

	Configuration configuration = config;
	DSLContext dsl = DSL.using(configuration);

	System.out.println(
		dsl.select(A.ID, A.FLAG)
			.from(A)
			.join(B).on(B.NAME.eq(A.NAME))
			.toString());
}
 

@Override
public Settings getSettings() {
    if(dialect == SQLDialect.POSTGRES) {
        return new Settings().withRenderNameStyle(RenderNameStyle.LOWER);
    }
    return updateSchema(dialect).map(s ->
            new Settings()
                    .withRenderNameStyle(RenderNameStyle.LOWER)
                    .withRenderMapping(new RenderMapping()
                    .withSchemata(
                        new MappedSchema().withInput(Club.CLUB.getName())
                                .withOutput(s))))
                .orElseGet(Settings::new);
}
 

private static SQLDialect SQLDialectFromDBEngine(final EmbeddedDB.DBEngine dbEngine) {
    switch (dbEngine) {
        case H2:
            return SQLDialect.H2;
        case MYSQL:
            return SQLDialect.MARIADB;
        case POSTGRESQL:
            return SQLDialect.POSTGRES;
        default:
            throw new IllegalArgumentException("Unsupported DB engine: " + dbEngine);
    }
}
 

@Override
protected SQLDialect getSQLDialect()
{
    return SQLDialect.POSTGRES;
}
 

/**
 * Applies the {@code array_agg} aggregate function on a field,
 * resulting in the input values being concatenated into an array.
 *
 * @param field the field to be aggregated
 * @param <T> the type of the field
 * @return a {@link Field} representing the array aggregate.
 *
 * @see <a href="http://www.postgresql.org/docs/9.3/static/functions-aggregate.html"/>
 */
@Support({SQLDialect.POSTGRES})
public static <T> Field<T[]> arrayAgg(Field<T> field) {
    return DSL.field("array_agg({0})", field.getDataType().getArrayDataType(), field);
}
 

/**
 * Like {@link #arrayAgg}, but uses {@code array_remove} to eliminate
 * SQL {@code NULL} values from the result.
 *
 * @param field the field to be aggregated
 * @param <T> the type of the field
 * @return a {@link Field} representing the array aggregate
 *
 * @see <a href="http://www.postgresql.org/docs/9.3/static/functions-aggregate.html"/>
 */
@Support({SQLDialect.POSTGRES})
public static <T> Field<T[]> arrayAggNoNulls(Field<T> field) {
    return DSL.field("array_remove(array_agg({0}), NULL)", field.getDataType().getArrayType(), field);
}