public RegionSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { super(database, namePrefix, version); this.regionParam = DSL.param("region", String.class); this.valueParam = database.stGeomFromText(regionParam); }
public LocationSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { super(database, namePrefix, version); this.locationParam = DSL.param("location", String.class); this.valueParam = database.stGeomFromText(locationParam); }
public StringSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { super(database, namePrefix, version); this.valueParam = DSL.param("value", database.stringIndexType()); }
public UuidSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { super(database, namePrefix, version); this.valueParam = DSL.param("value", database.uuidType()); }
public NumberSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { super(database, namePrefix, version); this.valueParam = DSL.param("value", database.doubleType()); }
/** * Create a named parameter with a generic type ({@link Object} / * {@link SQLDataType#OTHER}) and no initial value. * <p> * Try to avoid this method when using any of these databases, as these * databases may have trouble inferring the type of the bind value. Use * typed named parameters instead, using {@link #param(String, Class)} or * {@link #param(String, DataType)} * <ul> * <li> {@link SQLDialect#DB2}</li> * <li> {@link SQLDialect#DERBY}</li> * <li> {@link SQLDialect#H2}</li> * <li> {@link SQLDialect#HSQLDB}</li> * <li> {@link SQLDialect#INGRES}</li> * <li> {@link SQLDialect#SYBASE}</li> * </ul> * * @see #param(String, Object) */ @Support public static Param<Object> param(String name) { return param(name, Object.class); }
/** * Create a named parameter with a generic type ({@link Object} / * {@link SQLDataType#OTHER}) and no initial value. * <p> * Try to avoid this method when using any of these databases, as these * databases may have trouble inferring the type of the bind value. Use * typed named parameters instead, using {@link #param(String, Class)} or * {@link #param(String, DataType)} * <ul> * <li> {@link SQLDialect#DB2}</li> * <li> {@link SQLDialect#DERBY}</li> * <li> {@link SQLDialect#H2}</li> * <li> {@link SQLDialect#HSQLDB}</li> * <li> {@link SQLDialect#INGRES}</li> * <li> {@link SQLDialect#SYBASE}</li> * </ul> * * @see #param(String, Object) */ @Support public static Param<Object> param(String name) { return param(name, Object.class); }
/** * Create an unnamed parameter with a generic type ({@link Object} / * {@link SQLDataType#OTHER}) and no initial value. * <p> * Try to avoid this method when using any of these databases, as these * databases may have trouble inferring the type of the bind value. Use * typed named parameters instead, using {@link #param(Class)} or * {@link #param(DataType)} * <ul> * <li> {@link SQLDialect#DB2}</li> * <li> {@link SQLDialect#DERBY}</li> * <li> {@link SQLDialect#H2}</li> * <li> {@link SQLDialect#HSQLDB}</li> * <li> {@link SQLDialect#INGRES}</li> * <li> {@link SQLDialect#SYBASE}</li> * </ul> * * @see #param(String, Object) */ @Support public static <T> Param<Object> param() { return param(Object.class); }
/** * Create a named parameter with a defined type and no initial value. * * @see #param(String, Object) */ @Support public static <T> Param<T> param(String name, Class<T> type) { return param(name, DefaultDataType.getDataType(null, type)); }
/** * Create a named parameter with a defined type and no initial value. * * @see #param(String, Object) */ @Support public static <T> Param<T> param(String name, Class<T> type) { return param(name, DefaultDataType.getDataType(null, type)); }
/** * Create an unnamed parameter with a defined type and no initial value. * * @see #param(String, Object) */ @Support public static <T> Param<T> param(Class<T> type) { return param(DefaultDataType.getDataType(null, type)); }
/** * Create an unnamed parameter with the defined type of another field and no * initial value. * * @see #param(String, Object) */ @Support public static <T> Param<T> param(Field<T> field) { return param(field.getDataType()); }
/** * Create a named parameter with a defined type of another field and no * initial value. * * @see #param(String, Object) */ @Support public static <T> Param<T> param(String name, Field<T> type) { return param(name, type.getDataType()); }
protected AbstractSqlIndex(AbstractSqlDatabase database, String namePrefix, int version) { DataType<Integer> integerType = database.integerType(); DataType<UUID> uuidType = database.uuidType(); this.database = database; this.table = DSL.table(DSL.name(namePrefix + version)); this.idField = DSL.field(DSL.name("id"), uuidType); this.idParam = DSL.param(idField.getName(), uuidType); this.typeIdField = DSL.field(DSL.name("typeId"), uuidType); this.typeIdParam = DSL.param(typeIdField.getName(), uuidType); this.symbolIdField = DSL.field(DSL.name("symbolId"), integerType); this.symbolIdParam = DSL.param(symbolIdField.getName(), integerType); this.valueField = DSL.field(DSL.name("value")); }
@Override public String version(SchemaDefinition schema) { return "" + new DefaultConfiguration() .set(connection) .set(new Settings().withStatementType(STATIC_STATEMENT)) .dsl() .fetchValue( // [#2906] TODO Plain SQL statements do not yet support named parameters sql.replace(":schema_name", "?"), param("schema_name", schema.getInputName()) ); } }
@Override public String version(CatalogDefinition catalog) { return "" + new DefaultConfiguration() .set(connection) .set(new Settings().withStatementType(STATIC_STATEMENT)) .dsl() .fetchValue( // [#2906] TODO Plain SQL statements do not yet support named parameters sql.replace(":catalog_name", "?"), param("catalog_name", catalog.getInputName()) ); } }
.from(table.table) .where(removeField.lt(cutoffTime) .and(idField.gt(DSL.param(ID_GREATER_THAN_PARAM, 0L)))) .orderBy(idField) .limit(QUERY_LIMIT_ROWS.getValue());
private static final Field<?> parseBindVariable(ParserContext ctx) { switch (ctx.character()) { case '?': parse(ctx, '?'); return DSL.val(ctx.nextBinding(), Object.class); case ':': parse(ctx, ':', false); return DSL.param(parseIdentifier(ctx).last(), ctx.nextBinding()); default: throw ctx.exception("Illegal bind variable character"); } }