org.hibernate.dialect.function.SQLFunctionTemplate Java Exaples

Source File: Teradata14Dialect.java From lams with GNU General Public License v2.0

6 votes

public Teradata14Dialect() {
	super();
	//registerColumnType data types
	registerColumnType( Types.BIGINT, "BIGINT" );
	registerColumnType( Types.BINARY, "VARBYTE(100)" );
	registerColumnType( Types.LONGVARBINARY, "VARBYTE(32000)" );
	registerColumnType( Types.LONGVARCHAR, "VARCHAR(32000)" );

	getDefaultProperties().setProperty( Environment.USE_STREAMS_FOR_BINARY, "true" );
	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE );

	registerFunction( "current_time", new SQLFunctionTemplate( StandardBasicTypes.TIME, "current_time" ) );
	registerFunction( "current_date", new SQLFunctionTemplate( StandardBasicTypes.DATE, "current_date" ) );

	TeraIndexExporter =  new TeradataIndexExporter( this );
}

Source File: SQLServerDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

6 votes

public SQLServerDialect() {
	registerColumnType( Types.VARBINARY, "image" );
	registerColumnType( Types.VARBINARY, 8000, "varbinary($l)" );

	registerFunction( "second", new SQLFunctionTemplate(Hibernate.INTEGER, "datepart(second, ?1)") );
	registerFunction( "minute", new SQLFunctionTemplate(Hibernate.INTEGER, "datepart(minute, ?1)") );
	registerFunction( "hour", new SQLFunctionTemplate(Hibernate.INTEGER, "datepart(hour, ?1)") );
	registerFunction( "locate", new StandardSQLFunction("charindex", Hibernate.INTEGER) );

	registerFunction( "extract", new SQLFunctionTemplate( Hibernate.INTEGER, "datepart(?1, ?3)" ) );
	registerFunction( "mod", new SQLFunctionTemplate( Hibernate.INTEGER, "?1 % ?2" ) );
	registerFunction( "bit_length", new SQLFunctionTemplate( Hibernate.INTEGER, "datalength(?1) * 8" ) );

	registerFunction( "trim", new AnsiTrimEmulationFunction() );

	registerKeyword("top");
}

Source File: SQLServerDialect.java From lams with GNU General Public License v2.0

6 votes

/**
 * Constructs a SQLServerDialect
 */
public SQLServerDialect() {
	registerColumnType( Types.VARBINARY, "image" );
	registerColumnType( Types.VARBINARY, 8000, "varbinary($l)" );
	registerColumnType( Types.LONGVARBINARY, "image" );
	registerColumnType( Types.LONGVARCHAR, "text" );
	registerColumnType( Types.BOOLEAN, "bit" );

	registerFunction( "second", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "datepart(second, ?1)" ) );
	registerFunction( "minute", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "datepart(minute, ?1)" ) );
	registerFunction( "hour", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "datepart(hour, ?1)" ) );
	registerFunction( "locate", new StandardSQLFunction( "charindex", StandardBasicTypes.INTEGER ) );

	registerFunction( "extract", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "datepart(?1, ?3)" ) );
	registerFunction( "mod", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "?1 % ?2" ) );
	registerFunction( "bit_length", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "datalength(?1) * 8" ) );

	registerFunction( "trim", new AnsiTrimEmulationFunction() );

	registerKeyword( "top" );
	registerKeyword( "key" );

	this.limitHandler = new TopLimitHandler( false, false );
}

Source File: FunctionTemplateRegistrator.java From Knowage-Server with GNU Affero General Public License v3.0

6 votes

@Override
public void register(Dialect dialect) {
	logger.debug("IN");
	try {
		if (function.getCode() != null || !function.getCode().equals("")) {
			dialect.registerFunction(function.getName(),
					new SQLFunctionTemplate((Type) StandardBasicTypes.class.getField(function.getType()).get(null), function.getCode()));
		}

	} catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException e) {
		logger.error("Error while registering function", e);
		throw new SpagoBIEngineRuntimeException("Error while registering function", e);
	} finally {
		logger.debug("OUT");
	}

}

Source File: SQLiteDialect.java From oim-fx with MIT License

5 votes

public SQLiteDialect() {
	super();
	registerColumnType(Types.BIT, "integer");
	registerColumnType(Types.TINYINT, "tinyint");
	registerColumnType(Types.SMALLINT, "smallint");
	registerColumnType(Types.INTEGER, "integer");
	registerColumnType(Types.BIGINT, "bigint");
	registerColumnType(Types.FLOAT, "float");
	registerColumnType(Types.REAL, "real");
	registerColumnType(Types.DOUBLE, "double");
	registerColumnType(Types.NUMERIC, "numeric");
	registerColumnType(Types.DECIMAL, "decimal");
	registerColumnType(Types.CHAR, "char");
	registerColumnType(Types.VARCHAR, "varchar");
	registerColumnType(Types.LONGVARCHAR, "longvarchar");
	registerColumnType(Types.DATE, "date");
	registerColumnType(Types.TIME, "time");
	registerColumnType(Types.TIMESTAMP, "timestamp");
	registerColumnType(Types.BINARY, "blob");
	registerColumnType(Types.VARBINARY, "blob");
	registerColumnType(Types.LONGVARBINARY, "blob");
	// registerColumnType(Types.NULL, "null");
	registerColumnType(Types.BLOB, "blob");
	registerColumnType(Types.CLOB, "clob");
	registerColumnType(Types.BOOLEAN, "integer");

	registerFunction("concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "", "||", ""));
	registerFunction("mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "?1 % ?2"));
	registerFunction("substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING));
	registerFunction("substring", new StandardSQLFunction("substr", StandardBasicTypes.STRING));
}

Source File: SQLiteDialect.java From poli-libras with GNU General Public License v3.0

5 votes

public SQLiteDialect() {
	super();
	registerColumnType(Types.BIT, "integer");
	registerColumnType(Types.TINYINT, "tinyint");
	registerColumnType(Types.SMALLINT, "smallint");
	registerColumnType(Types.INTEGER, "integer");
	registerColumnType(Types.BIGINT, "bigint");
	registerColumnType(Types.FLOAT, "float");
	registerColumnType(Types.REAL, "real");
	registerColumnType(Types.DOUBLE, "double");
	registerColumnType(Types.NUMERIC, "numeric");
	registerColumnType(Types.DECIMAL, "decimal");
	registerColumnType(Types.CHAR, "char");
	registerColumnType(Types.VARCHAR, "varchar");
	registerColumnType(Types.LONGVARCHAR, "longvarchar");
	registerColumnType(Types.DATE, "date");
	registerColumnType(Types.TIME, "time");
	registerColumnType(Types.TIMESTAMP, "timestamp");
	registerColumnType(Types.BINARY, "blob");
	registerColumnType(Types.VARBINARY, "blob");
	registerColumnType(Types.LONGVARBINARY, "blob");
	// registerColumnType(Types.NULL, "null");
	registerColumnType(Types.BLOB, "blob");
	registerColumnType(Types.CLOB, "clob");
	registerColumnType(Types.BOOLEAN, "integer");

	 registerFunction( "concat", new VarArgsSQLFunction(Hibernate.STRING, "", "||", "") );
	 registerFunction( "mod", new SQLFunctionTemplate( Hibernate.INTEGER, "?1 % ?2" ) );
	 registerFunction( "substr", new StandardSQLFunction("substr", Hibernate.STRING) );
	 registerFunction( "substring", new StandardSQLFunction( "substr", Hibernate.STRING ) );
}

Source File: HibernateUtil.java From unitime with Apache License 2.0

5 votes

public static void addAddDateToDialect() {
	SessionFactoryImplementor hibSessionFactory = (SessionFactoryImplementor)new _RootDAO().getSession().getSessionFactory();
	Dialect dialect = hibSessionFactory.getDialect();
	if (isPostgress() && !dialect.getFunctions().containsKey("adddate")) {
		dialect.getFunctions().put("adddate", new SQLFunctionTemplate(IntegerType.INSTANCE, "?1 + (?2) * interval '1 day'"));
	}
}

Source File: HibernateUtil.java From unitime with Apache License 2.0

5 votes

public static void addBitwiseOperationsToDialect() {
	SessionFactoryImplementor hibSessionFactory = (SessionFactoryImplementor)new _RootDAO().getSession().getSessionFactory();
	Dialect dialect = hibSessionFactory.getDialect();
	if (!dialect.getFunctions().containsKey("bit_and")) {
		if (isOracle())
			dialect.getFunctions().put("bit_and", new StandardSQLFunction("bitand", IntegerType.INSTANCE));
		else if (isPostgress())
			dialect.getFunctions().put("bit_and", new SQLFunctionTemplate(IntegerType.INSTANCE, "cast(?1 as int) & cast(?2 as int)"));
		else
			dialect.getFunctions().put("bit_and", new SQLFunctionTemplate(IntegerType.INSTANCE, "?1 & ?2"));
	}
}

Source File: SQLiteDialect.java From webdsl with Apache License 2.0

5 votes

public SQLiteDialect() {
	super();
	registerColumnType(Types.BIT, "integer");
	registerColumnType(Types.TINYINT, "tinyint");
	registerColumnType(Types.SMALLINT, "smallint");
	registerColumnType(Types.INTEGER, "integer");
	registerColumnType(Types.BIGINT, "bigint");
	registerColumnType(Types.FLOAT, "float");
	registerColumnType(Types.REAL, "real");
	registerColumnType(Types.DOUBLE, "double");
	registerColumnType(Types.NUMERIC, "numeric");
	registerColumnType(Types.DECIMAL, "decimal");
	registerColumnType(Types.CHAR, "char");
	registerColumnType(Types.VARCHAR, "varchar");
	registerColumnType(Types.LONGVARCHAR, "longvarchar");
	registerColumnType(Types.DATE, "date");
	registerColumnType(Types.TIME, "time");
	registerColumnType(Types.TIMESTAMP, "timestamp");
	registerColumnType(Types.BINARY, "blob");
	registerColumnType(Types.VARBINARY, "blob");
	registerColumnType(Types.LONGVARBINARY, "blob");
	// registerColumnType(Types.NULL, "null");
	registerColumnType(Types.BLOB, "blob");
	registerColumnType(Types.CLOB, "clob");
	registerColumnType(Types.BOOLEAN, "integer");

	registerFunction("concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "",
			"||", ""));
	registerFunction("mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER,
			"?1 % ?2"));
	registerFunction("substr", new StandardSQLFunction("substr",
			StandardBasicTypes.STRING));
	registerFunction("substring", new StandardSQLFunction("substr",
			StandardBasicTypes.STRING));
}

Source File: DateTruncUtcFunctionTest.java From high-performance-java-persistence with Apache License 2.0

5 votes

@Override
public void contribute(MetadataBuilder metadataBuilder) {
    metadataBuilder.applySqlFunction(
            "date_trunc",
            new SQLFunctionTemplate(
                    StandardBasicTypes.TIMESTAMP,
                    "date_trunc('day', (?1 AT TIME ZONE 'UTC'))"
            )
    );
}

Source File: DateTruncTimeZoneFunctionTest.java From high-performance-java-persistence with Apache License 2.0

5 votes

@Override
public void contribute(MetadataBuilder metadataBuilder) {
    metadataBuilder.applySqlFunction(
            "date_trunc",
            new SQLFunctionTemplate(
                    StandardBasicTypes.TIMESTAMP,
                    "date_trunc('day', (?1 AT TIME ZONE ?2))"
            )
    );
}

Source File: SQLiteDialect.java From wangmarket with Apache License 2.0

5 votes

public SQLiteDialect() {
	super();
	registerColumnType(Types.BIT, "integer");
	registerColumnType(Types.TINYINT, "tinyint");
	registerColumnType(Types.SMALLINT, "smallint");
	registerColumnType(Types.INTEGER, "integer");
	registerColumnType(Types.BIGINT, "bigint");
	registerColumnType(Types.FLOAT, "float");
	registerColumnType(Types.REAL, "real");
	registerColumnType(Types.DOUBLE, "double");
	registerColumnType(Types.NUMERIC, "numeric");
	registerColumnType(Types.DECIMAL, "decimal");
	registerColumnType(Types.CHAR, "char");
	registerColumnType(Types.VARCHAR, 255, "varchar($l)");
	registerColumnType(Types.LONGVARCHAR, "longvarchar");
	registerColumnType(Types.DATE, "date");
	registerColumnType(Types.TIME, "time");
	registerColumnType(Types.TIMESTAMP, "timestamp");
	registerColumnType(Types.BINARY, "blob");
	registerColumnType(Types.VARBINARY, "blob");
	registerColumnType(Types.LONGVARBINARY, "blob");
	registerColumnType(Types.BLOB, "blob");
	registerColumnType(Types.CLOB, "clob");
	registerColumnType(Types.BOOLEAN, "integer");
	registerHibernateType(Types.NULL, "null");
	
	registerFunction("concat", new VarArgsSQLFunction(StringType.INSTANCE,
			"", "||", ""));
	registerFunction("mod", new SQLFunctionTemplate(IntegerType.INSTANCE,
			"?1 % ?2"));
	registerFunction("substr", new StandardSQLFunction("substr",
			StringType.INSTANCE));
	registerFunction("substring", new StandardSQLFunction("substr",
			StringType.INSTANCE));
}

Source File: CustomOracleSpatialDialect.java From Knowage-Server with GNU Affero General Public License v3.0

5 votes

public CustomOracleSpatialDialect() {
	super();

	InlineFunctionRegistrationManager.registerInlineFunctions(this);

	registerFunction("dwithin", new StandardSQLFunction("SDO_WITHIN_DISTANCE", StandardBasicTypes.STRING));
	registerFunction("spatial_contains", new StandardSQLFunction("SDO_CONTAINS", StandardBasicTypes.BOOLEAN));
	registerFunction("intersection", new StandardSQLFunction("SDO_GEOM.SDO_INTERSECTION", GeometryUserType.TYPE));
	registerFunction("spatial_nn", new StandardSQLFunction("SDO_NN", StandardBasicTypes.BIG_DECIMAL));
	registerFunction("length_spa", new StandardSQLFunction("SDO_GEOM.SDO_LENGTH", StandardBasicTypes.BIG_DECIMAL));
	registerFunction("filter", new StandardSQLFunction("SDO_FILTER", StandardBasicTypes.STRING));
	registerFunction("distance", new StandardSQLFunction("SDO_GEOM.SDO_DISTANCE", StandardBasicTypes.BIG_DECIMAL));
	registerFunction("union", new StandardSQLFunction("SDO_GEOM.SDO_UNION", GeometryUserType.TYPE));
	registerFunction("centroid", new StandardSQLFunction("SDO_GEOM.SDO_CENTROID", GeometryUserType.TYPE));
	registerFunction("covers", new StandardSQLFunction("SDO_COVERS", StandardBasicTypes.STRING));
	registerFunction("coveredby", new StandardSQLFunction("SDO_COVEREDBY", StandardBasicTypes.STRING));
	registerFunction("relate", new StandardSQLFunction("SDO_GEOM.RELATE", StandardBasicTypes.STRING));
	registerFunction("inside", new StandardSQLFunction("SDO_INSIDE", StandardBasicTypes.STRING));
	registerFunction("to_km", new SQLFunctionTemplate(StandardBasicTypes.BIG_DECIMAL, "((?1) * 1.852)"));
	registerFunction("to_nm", new SQLFunctionTemplate(StandardBasicTypes.BIG_DECIMAL, "((?1) / 1.852)"));
	registerFunction("extract", new SQLFunctionTemplate(StandardBasicTypes.LONG, "extract (?1 from (?2))"));
	registerFunction("to_timezone", new SQLFunctionTemplate(StandardBasicTypes.TIMESTAMP, "((?1) + ?2/24)") {
		@Override
		public String render(Type argumentType, List args, SessionFactoryImplementor factory) {
			if (args == null || args.size() != 2) {
				throw new QueryException("to_timezone() requires two arguments");
			}
			if (!((String) args.get(1)).matches("\\-?((1?[0-9])|(2[0-3]))")) {
				throw new QueryException("to_timezone()'s second parameter must be a number from -23 to +23");
			}
			return super.render(argumentType, args, factory);
		}
	});
	registerFunction("latitude", new SQLFunctionTemplate(StandardBasicTypes.STRING, "CASE ?1.Get_GType() WHEN 1 THEN to_char(?1.sdo_point.y) ELSE '' END"));
	registerFunction("longitude",
			new SQLFunctionTemplate(StandardBasicTypes.STRING, "CASE ?1.Get_GType() WHEN 1 THEN to_char(?1.sdo_point.x) ELSE '' END"));
}

Source File: SQLiteDialect.java From springboot-sqlite-mini-website with Apache License 2.0

5 votes

public SQLiteDialect() {
    registerColumnType(Types.BIT, "integer");
    registerColumnType(Types.TINYINT, "tinyint");
    registerColumnType(Types.SMALLINT, "smallint");
    registerColumnType(Types.INTEGER, "integer");
    registerColumnType(Types.BIGINT, "bigint");
    registerColumnType(Types.FLOAT, "float");
    registerColumnType(Types.REAL, "real");
    registerColumnType(Types.DOUBLE, "double");
    registerColumnType(Types.NUMERIC, "numeric");
    registerColumnType(Types.DECIMAL, "decimal");
    registerColumnType(Types.CHAR, "char");
    registerColumnType(Types.VARCHAR, "varchar");
    registerColumnType(Types.LONGVARCHAR, "longvarchar");
    registerColumnType(Types.DATE, "date");
    registerColumnType(Types.TIME, "time");
    registerColumnType(Types.TIMESTAMP, "timestamp");
    registerColumnType(Types.BINARY, "blob");
    registerColumnType(Types.VARBINARY, "blob");
    registerColumnType(Types.LONGVARBINARY, "blob");
    // registerColumnType(Types.NULL, "null");
    registerColumnType(Types.BLOB, "blob");
    registerColumnType(Types.CLOB, "clob");
    registerColumnType(Types.BOOLEAN, "integer");

    registerFunction("concat", new VarArgsSQLFunction(StringType.INSTANCE, "", "||", ""));
    registerFunction("mod", new SQLFunctionTemplate(StringType.INSTANCE, "?1 % ?2"));
    registerFunction("substr", new StandardSQLFunction("substr", StringType.INSTANCE));
    registerFunction("substring", new StandardSQLFunction("substr", StringType.INSTANCE));
}

Source File: SybaseASE157Dialect.java From lams with GNU General Public License v2.0

5 votes

/**
 * Constructs a SybaseASE157Dialect
 */
public SybaseASE157Dialect() {
	super();

	registerFunction( "create_locator", new SQLFunctionTemplate( StandardBasicTypes.BINARY, "create_locator(?1, ?2)" ) );
	registerFunction( "locator_literal", new SQLFunctionTemplate( StandardBasicTypes.BINARY, "locator_literal(?1, ?2)" ) );
	registerFunction( "locator_valid", new SQLFunctionTemplate( StandardBasicTypes.BOOLEAN, "locator_valid(?1)" ) );
	registerFunction( "return_lob", new SQLFunctionTemplate( StandardBasicTypes.BINARY, "return_lob(?1, ?2)" ) );
	registerFunction( "setdata", new SQLFunctionTemplate( StandardBasicTypes.BOOLEAN, "setdata(?1, ?2, ?3)" ) );
	registerFunction( "charindex", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "charindex(?1, ?2, ?3)" ) );
}

Source File: InformixDialect.java From lams with GNU General Public License v2.0

5 votes

/**
 * Creates new <code>InformixDialect</code> instance. Sets up the JDBC /
 * Informix type mappings.
 */
public InformixDialect() {
	super();

	registerColumnType( Types.BIGINT, "int8" );
	registerColumnType( Types.BINARY, "byte" );
	// Informix doesn't have a bit type
	registerColumnType( Types.BIT, "smallint" );
	registerColumnType( Types.CHAR, "char($l)" );
	registerColumnType( Types.DATE, "date" );
	registerColumnType( Types.DECIMAL, "decimal" );
	registerColumnType( Types.DOUBLE, "float" );
	registerColumnType( Types.FLOAT, "smallfloat" );
	registerColumnType( Types.INTEGER, "integer" );
	// or BYTE
	registerColumnType( Types.LONGVARBINARY, "blob" );
	// or TEXT?
	registerColumnType( Types.LONGVARCHAR, "clob" );
	// or MONEY
	registerColumnType( Types.NUMERIC, "decimal" );
	registerColumnType( Types.REAL, "smallfloat" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.TIMESTAMP, "datetime year to fraction(5)" );
	registerColumnType( Types.TIME, "datetime hour to second" );
	registerColumnType( Types.TINYINT, "smallint" );
	registerColumnType( Types.VARBINARY, "byte" );
	registerColumnType( Types.VARCHAR, "varchar($l)" );
	registerColumnType( Types.VARCHAR, 255, "varchar($l)" );
	registerColumnType( Types.VARCHAR, 32739, "lvarchar($l)" );

	registerFunction( "concat", new VarArgsSQLFunction( StandardBasicTypes.STRING, "(", "||", ")" ) );
	registerFunction( "substring", new SQLFunctionTemplate(StandardBasicTypes.STRING, "substring(?1 FROM ?2 FOR ?3)"));
	registerFunction( "substr", new SQLFunctionTemplate( StandardBasicTypes.STRING, "substr(?1, ?2, ?3)"));
	registerFunction( "coalesce", new NvlFunction());
	registerFunction( "nvl", new NvlFunction());
	registerFunction( "current_timestamp", new NoArgSQLFunction( "current", StandardBasicTypes.TIMESTAMP, false ) );
	registerFunction( "current_date", new NoArgSQLFunction( "today", StandardBasicTypes.DATE, false ) );

	uniqueDelegate = new InformixUniqueDelegate( this );
}

Source File: SQLiteDialect.java From MonitorClient with Apache License 2.0

5 votes

public SQLiteDialect() {
    registerColumnType(Types.BIT, "integer");
    registerColumnType(Types.TINYINT, "tinyint");
    registerColumnType(Types.SMALLINT, "smallint");
    registerColumnType(Types.INTEGER, "integer");
    registerColumnType(Types.BIGINT, "bigint");
    registerColumnType(Types.FLOAT, "float");
    registerColumnType(Types.REAL, "real");
    registerColumnType(Types.DOUBLE, "double");
    registerColumnType(Types.NUMERIC, "numeric");
    registerColumnType(Types.DECIMAL, "decimal");
    registerColumnType(Types.CHAR, "char");
    registerColumnType(Types.VARCHAR, "varchar");
    registerColumnType(Types.LONGVARCHAR, "longvarchar");
    registerColumnType(Types.DATE, "date");
    registerColumnType(Types.TIME, "time");
    registerColumnType(Types.TIMESTAMP, "timestamp");
    registerColumnType(Types.BINARY, "blob");
    registerColumnType(Types.VARBINARY, "blob");
    registerColumnType(Types.LONGVARBINARY, "blob");
    // registerColumnType(Types.NULL, "null");
    registerColumnType(Types.BLOB, "blob");
    registerColumnType(Types.CLOB, "clob");
    registerColumnType(Types.BOOLEAN, "integer");

    registerFunction( "concat", new VarArgsSQLFunction(StringType.INSTANCE, "", "||", "") );
    registerFunction( "mod", new SQLFunctionTemplate( StringType.INSTANCE, "?1 % ?2" ) );
    registerFunction( "substr", new StandardSQLFunction("substr", StringType.INSTANCE) );
    registerFunction( "substring", new StandardSQLFunction( "substr", StringType.INSTANCE) );
}

Source File: PostgreSQLDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

public PostgreSQLDialect() {
	super();
	registerColumnType( Types.BIT, "bool" );
	registerColumnType( Types.BIGINT, "int8" );
	registerColumnType( Types.SMALLINT, "int2" );
	registerColumnType( Types.TINYINT, "int2" );
	registerColumnType( Types.INTEGER, "int4" );
	registerColumnType( Types.CHAR, "char(1)" );
	registerColumnType( Types.VARCHAR, "varchar($l)" );
	registerColumnType( Types.FLOAT, "float4" );
	registerColumnType( Types.DOUBLE, "float8" );
	registerColumnType( Types.DATE, "date" );
	registerColumnType( Types.TIME, "time" );
	registerColumnType( Types.TIMESTAMP, "timestamp" );
	registerColumnType( Types.VARBINARY, "bytea" );
	registerColumnType( Types.CLOB, "text" );
	registerColumnType( Types.BLOB, "oid" );
	registerColumnType( Types.NUMERIC, "numeric($p, $s)" );

	registerFunction( "abs", new StandardSQLFunction("abs") );
	registerFunction( "sign", new StandardSQLFunction("sign", Hibernate.INTEGER) );

	registerFunction( "acos", new StandardSQLFunction("acos", Hibernate.DOUBLE) );
	registerFunction( "asin", new StandardSQLFunction("asin", Hibernate.DOUBLE) );
	registerFunction( "atan", new StandardSQLFunction("atan", Hibernate.DOUBLE) );
	registerFunction( "cos", new StandardSQLFunction("cos", Hibernate.DOUBLE) );
	registerFunction( "cot", new StandardSQLFunction("cot", Hibernate.DOUBLE) );
	registerFunction( "exp", new StandardSQLFunction("exp", Hibernate.DOUBLE) );
	registerFunction( "ln", new StandardSQLFunction("ln", Hibernate.DOUBLE) );
	registerFunction( "log", new StandardSQLFunction("log", Hibernate.DOUBLE) );
	registerFunction( "sin", new StandardSQLFunction("sin", Hibernate.DOUBLE) );
	registerFunction( "sqrt", new StandardSQLFunction("sqrt", Hibernate.DOUBLE) );
	registerFunction( "cbrt", new StandardSQLFunction("cbrt", Hibernate.DOUBLE) );
	registerFunction( "tan", new StandardSQLFunction("tan", Hibernate.DOUBLE) );
	registerFunction( "radians", new StandardSQLFunction("radians", Hibernate.DOUBLE) );
	registerFunction( "degrees", new StandardSQLFunction("degrees", Hibernate.DOUBLE) );

	registerFunction( "stddev", new StandardSQLFunction("stddev", Hibernate.DOUBLE) );
	registerFunction( "variance", new StandardSQLFunction("variance", Hibernate.DOUBLE) );

	registerFunction( "random", new NoArgSQLFunction("random", Hibernate.DOUBLE) );

	registerFunction( "round", new StandardSQLFunction("round") );
	registerFunction( "trunc", new StandardSQLFunction("trunc") );
	registerFunction( "ceil", new StandardSQLFunction("ceil") );
	registerFunction( "floor", new StandardSQLFunction("floor") );

	registerFunction( "chr", new StandardSQLFunction("chr", Hibernate.CHARACTER) );
	registerFunction( "lower", new StandardSQLFunction("lower") );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "substr", new StandardSQLFunction("substr", Hibernate.STRING) );
	registerFunction( "initcap", new StandardSQLFunction("initcap") );
	registerFunction( "to_ascii", new StandardSQLFunction("to_ascii") );
	registerFunction( "quote_ident", new StandardSQLFunction("quote_ident", Hibernate.STRING) );
	registerFunction( "quote_literal", new StandardSQLFunction("quote_literal", Hibernate.STRING) );
	registerFunction( "md5", new StandardSQLFunction("md5") );
	registerFunction( "ascii", new StandardSQLFunction("ascii", Hibernate.INTEGER) );
	registerFunction( "length", new StandardSQLFunction("length", Hibernate.LONG) );
	registerFunction( "char_length", new StandardSQLFunction("char_length", Hibernate.LONG) );
	registerFunction( "bit_length", new StandardSQLFunction("bit_length", Hibernate.LONG) );
	registerFunction( "octet_length", new StandardSQLFunction("octet_length", Hibernate.LONG) );

	registerFunction( "current_date", new NoArgSQLFunction("current_date", Hibernate.DATE, false) );
	registerFunction( "current_time", new NoArgSQLFunction("current_time", Hibernate.TIME, false) );
	registerFunction( "current_timestamp", new NoArgSQLFunction("current_timestamp", Hibernate.TIMESTAMP, false) );
	registerFunction( "localtime", new NoArgSQLFunction("localtime", Hibernate.TIME, false) );
	registerFunction( "localtimestamp", new NoArgSQLFunction("localtimestamp", Hibernate.TIMESTAMP, false) );
	registerFunction( "now", new NoArgSQLFunction("now", Hibernate.TIMESTAMP) );
	registerFunction( "timeofday", new NoArgSQLFunction("timeofday", Hibernate.STRING) );
	registerFunction( "age", new StandardSQLFunction("age") );

	registerFunction( "current_user", new NoArgSQLFunction("current_user", Hibernate.STRING, false) );
	registerFunction( "session_user", new NoArgSQLFunction("session_user", Hibernate.STRING, false) );
	registerFunction( "user", new NoArgSQLFunction("user", Hibernate.STRING, false) );
	registerFunction( "current_database", new NoArgSQLFunction("current_database", Hibernate.STRING, true) );
	registerFunction( "current_schema", new NoArgSQLFunction("current_schema", Hibernate.STRING, true) );
	
	registerFunction( "to_char", new StandardSQLFunction("to_char", Hibernate.STRING) );
	registerFunction( "to_date", new StandardSQLFunction("to_date", Hibernate.DATE) );
	registerFunction( "to_timestamp", new StandardSQLFunction("to_timestamp", Hibernate.TIMESTAMP) );
	registerFunction( "to_number", new StandardSQLFunction("to_number", Hibernate.BIG_DECIMAL) );

	registerFunction( "concat", new VarArgsSQLFunction( Hibernate.STRING, "(","||",")" ) );

	registerFunction( "locate", new PositionSubstringFunction() );

	registerFunction( "str", new SQLFunctionTemplate(Hibernate.STRING, "cast(?1 as varchar)") );

	getDefaultProperties().setProperty(Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE);
}

Source File: SQLiteDialect.java From butterfly with Apache License 2.0

4 votes

public SQLiteDialect() {
    registerColumnType(Types.BIT, "boolean");
    registerColumnType(Types.TINYINT, "tinyint");
    registerColumnType(Types.SMALLINT, "smallint");
    registerColumnType(Types.INTEGER, "integer");
    registerColumnType(Types.BIGINT, "bigint");
    registerColumnType(Types.FLOAT, "float");
    registerColumnType(Types.REAL, "real");
    registerColumnType(Types.DOUBLE, "double");
    registerColumnType(Types.NUMERIC, "numeric($p, $s)");
    registerColumnType(Types.DECIMAL, "decimal");
    registerColumnType(Types.CHAR, "char");
    registerColumnType(Types.VARCHAR, "varchar($l)");
    registerColumnType(Types.LONGVARCHAR, "longvarchar");
    registerColumnType(Types.DATE, "date");
    registerColumnType(Types.TIME, "time");
    registerColumnType(Types.TIMESTAMP, "datetime");
    registerColumnType(Types.BINARY, "blob");
    registerColumnType(Types.VARBINARY, "blob");
    registerColumnType(Types.LONGVARBINARY, "blob");
    registerColumnType(Types.BLOB, "blob");
    registerColumnType(Types.CLOB, "clob");
    registerColumnType(Types.BOOLEAN, "boolean");

    //registerFunction( "abs", new StandardSQLFunction("abs") );
    registerFunction( "concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "", "||", "") );
    //registerFunction( "length", new StandardSQLFunction("length", StandardBasicTypes.LONG) );
    //registerFunction( "lower", new StandardSQLFunction("lower") );
    registerFunction( "mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "?1 % ?2" ) );
    registerFunction( "quote", new StandardSQLFunction("quote", StandardBasicTypes.STRING) );
    registerFunction( "random", new NoArgSQLFunction("random", StandardBasicTypes.INTEGER) );
    registerFunction( "round", new StandardSQLFunction("round") );
    registerFunction( "substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING) );
    registerFunction( "substring", new SQLFunctionTemplate( StandardBasicTypes.STRING, "substr(?1, ?2, ?3)" ) );
    registerFunction( "trim", new AbstractAnsiTrimEmulationFunction() {
        protected SQLFunction resolveBothSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1)");
        }

        protected SQLFunction resolveBothSpaceTrimFromFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?2)");
        }

        protected SQLFunction resolveLeadingSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1)");
        }

        protected SQLFunction resolveTrailingSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1)");
        }

        protected SQLFunction resolveBothTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1, ?2)");
        }

        protected SQLFunction resolveLeadingTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1, ?2)");
        }

        protected SQLFunction resolveTrailingTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1, ?2)");
        }
    } );
    //registerFunction( "upper", new StandardSQLFunction("upper") );
}

Source File: SQLiteDialect.java From yeti with MIT License

4 votes

public SQLiteDialect() {
    registerColumnType(Types.BIT, "boolean");
    registerColumnType(Types.TINYINT, "tinyint");
    registerColumnType(Types.SMALLINT, "smallint");
    registerColumnType(Types.INTEGER, "integer");
    registerColumnType(Types.BIGINT, "bigint");
    registerColumnType(Types.FLOAT, "float");
    registerColumnType(Types.REAL, "real");
    registerColumnType(Types.DOUBLE, "double");
    registerColumnType(Types.NUMERIC, "numeric($p, $s)");
    registerColumnType(Types.DECIMAL, "decimal");
    registerColumnType(Types.CHAR, "char");
    registerColumnType(Types.VARCHAR, "varchar($l)");
    registerColumnType(Types.LONGVARCHAR, "longvarchar");
    registerColumnType(Types.DATE, "date");
    registerColumnType(Types.TIME, "time");
    registerColumnType(Types.TIMESTAMP, "datetime");
    registerColumnType(Types.BINARY, "blob");
    registerColumnType(Types.VARBINARY, "blob");
    registerColumnType(Types.LONGVARBINARY, "blob");
    registerColumnType(Types.BLOB, "blob");
    registerColumnType(Types.CLOB, "clob");
    registerColumnType(Types.BOOLEAN, "boolean");

    registerFunction("concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "", "||", ""));
    registerFunction("mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "?1 % ?2"));
    registerFunction("quote", new StandardSQLFunction("quote", StandardBasicTypes.STRING));
    registerFunction("random", new NoArgSQLFunction("random", StandardBasicTypes.INTEGER));
    registerFunction("round", new StandardSQLFunction("round"));
    registerFunction("substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING));
    registerFunction("trim", new AbstractAnsiTrimEmulationFunction() {
        @Override
        protected SQLFunction resolveBothSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1)");
        }

        @Override
        protected SQLFunction resolveBothSpaceTrimFromFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?2)");
        }

        @Override
        protected SQLFunction resolveLeadingSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1)");
        }

        @Override
        protected SQLFunction resolveTrailingSpaceTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1)");
        }

        @Override
        protected SQLFunction resolveBothTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1, ?2)");
        }

        @Override
        protected SQLFunction resolveLeadingTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1, ?2)");
        }

        @Override
        protected SQLFunction resolveTrailingTrimFunction() {
            return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1, ?2)");
        }
    });
}

Source File: ExtendedMySQL5InnoDBDialect.java From wallride with Apache License 2.0

4 votes

public ExtendedMySQL5InnoDBDialect() {
	super();
	registerFunction("regexp", new SQLFunctionTemplate(StandardBasicTypes.BOOLEAN, "?1 REGEXP ?2"));
}

Source File: TeradataDialect.java From lams with GNU General Public License v2.0

4 votes

/**
 * Constructor
 */
public TeradataDialect() {
	super();
	//registerColumnType data types
	registerColumnType( Types.NUMERIC, "NUMERIC($p,$s)" );
	registerColumnType( Types.DOUBLE, "DOUBLE PRECISION" );
	registerColumnType( Types.BIGINT, "NUMERIC(18,0)" );
	registerColumnType( Types.BIT, "BYTEINT" );
	registerColumnType( Types.TINYINT, "BYTEINT" );
	registerColumnType( Types.VARBINARY, "VARBYTE($l)" );
	registerColumnType( Types.BINARY, "BYTEINT" );
	registerColumnType( Types.LONGVARCHAR, "LONG VARCHAR" );
	registerColumnType( Types.CHAR, "CHAR(1)" );
	registerColumnType( Types.DECIMAL, "DECIMAL" );
	registerColumnType( Types.INTEGER, "INTEGER" );
	registerColumnType( Types.SMALLINT, "SMALLINT" );
	registerColumnType( Types.FLOAT, "FLOAT" );
	registerColumnType( Types.VARCHAR, "VARCHAR($l)" );
	registerColumnType( Types.DATE, "DATE" );
	registerColumnType( Types.TIME, "TIME" );
	registerColumnType( Types.TIMESTAMP, "TIMESTAMP" );
	registerColumnType( Types.BOOLEAN, "BYTEINT" );  // hibernate seems to ignore this type...
	registerColumnType( Types.BLOB, "BLOB" );
	registerColumnType( Types.CLOB, "CLOB" );

	registerFunction( "year", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "extract(year from ?1)" ) );
	registerFunction( "length", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "character_length(?1)" ) );
	registerFunction( "concat", new VarArgsSQLFunction( StandardBasicTypes.STRING, "(", "||", ")" ) );
	registerFunction( "substring", new SQLFunctionTemplate( StandardBasicTypes.STRING, "substring(?1 from ?2 for ?3)" ) );
	registerFunction( "locate", new SQLFunctionTemplate( StandardBasicTypes.STRING, "position(?1 in ?2)" ) );
	registerFunction( "mod", new SQLFunctionTemplate( StandardBasicTypes.STRING, "?1 mod ?2" ) );
	registerFunction( "str", new SQLFunctionTemplate( StandardBasicTypes.STRING, "cast(?1 as varchar(255))" ) );

	// bit_length feels a bit broken to me. We have to cast to char in order to
	// pass when a numeric value is supplied. But of course the answers given will
	// be wildly different for these two datatypes. 1234.5678 will be 9 bytes as
	// a char string but will be 8 or 16 bytes as a true numeric.
	// Jay Nance 2006-09-22
	registerFunction(
			"bit_length", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "octet_length(cast(?1 as char))*4" )
	);

	// The preference here would be
	//   SQLFunctionTemplate( StandardBasicTypes.TIMESTAMP, "current_timestamp(?1)", false)
	// but this appears not to work.
	// Jay Nance 2006-09-22
	registerFunction( "current_timestamp", new SQLFunctionTemplate( StandardBasicTypes.TIMESTAMP, "current_timestamp" ) );
	registerFunction( "current_time", new SQLFunctionTemplate( StandardBasicTypes.TIMESTAMP, "current_time" ) );
	registerFunction( "current_date", new SQLFunctionTemplate( StandardBasicTypes.TIMESTAMP, "current_date" ) );
	// IBID for current_time and current_date

	registerKeyword( "password" );
	registerKeyword( "type" );
	registerKeyword( "title" );
	registerKeyword( "year" );
	registerKeyword( "month" );
	registerKeyword( "summary" );
	registerKeyword( "alias" );
	registerKeyword( "value" );
	registerKeyword( "first" );
	registerKeyword( "role" );
	registerKeyword( "account" );
	registerKeyword( "class" );

	// Tell hibernate to use getBytes instead of getBinaryStream
	getDefaultProperties().setProperty( Environment.USE_STREAMS_FOR_BINARY, "false" );
	// No batch statements
	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, NO_BATCH );
}

Source File: OracleStoredProcedureTest.java From high-performance-java-persistence with Apache License 2.0

4 votes

@Override
protected void registerFunctions() {
    super.registerFunctions();
    registerFunction( "fn_count_comments", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "fn_count_comments(?1)" ) );
}

Source File: Oracle8iDialect.java From lams with GNU General Public License v2.0

4 votes

protected void registerFunctions() {
	registerFunction( "abs", new StandardSQLFunction("abs") );
	registerFunction( "sign", new StandardSQLFunction("sign", StandardBasicTypes.INTEGER) );

	registerFunction( "acos", new StandardSQLFunction("acos", StandardBasicTypes.DOUBLE) );
	registerFunction( "asin", new StandardSQLFunction("asin", StandardBasicTypes.DOUBLE) );
	registerFunction( "atan", new StandardSQLFunction("atan", StandardBasicTypes.DOUBLE) );
	registerFunction( "bitand", new StandardSQLFunction("bitand") );
	registerFunction( "cos", new StandardSQLFunction("cos", StandardBasicTypes.DOUBLE) );
	registerFunction( "cosh", new StandardSQLFunction("cosh", StandardBasicTypes.DOUBLE) );
	registerFunction( "exp", new StandardSQLFunction("exp", StandardBasicTypes.DOUBLE) );
	registerFunction( "ln", new StandardSQLFunction("ln", StandardBasicTypes.DOUBLE) );
	registerFunction( "sin", new StandardSQLFunction("sin", StandardBasicTypes.DOUBLE) );
	registerFunction( "sinh", new StandardSQLFunction("sinh", StandardBasicTypes.DOUBLE) );
	registerFunction( "stddev", new StandardSQLFunction("stddev", StandardBasicTypes.DOUBLE) );
	registerFunction( "sqrt", new StandardSQLFunction("sqrt", StandardBasicTypes.DOUBLE) );
	registerFunction( "tan", new StandardSQLFunction("tan", StandardBasicTypes.DOUBLE) );
	registerFunction( "tanh", new StandardSQLFunction("tanh", StandardBasicTypes.DOUBLE) );
	registerFunction( "variance", new StandardSQLFunction("variance", StandardBasicTypes.DOUBLE) );

	registerFunction( "round", new StandardSQLFunction("round") );
	registerFunction( "trunc", new StandardSQLFunction("trunc") );
	registerFunction( "ceil", new StandardSQLFunction("ceil") );
	registerFunction( "floor", new StandardSQLFunction("floor") );

	registerFunction( "chr", new StandardSQLFunction("chr", StandardBasicTypes.CHARACTER) );
	registerFunction( "initcap", new StandardSQLFunction("initcap") );
	registerFunction( "lower", new StandardSQLFunction("lower") );
	registerFunction( "ltrim", new StandardSQLFunction("ltrim") );
	registerFunction( "rtrim", new StandardSQLFunction("rtrim") );
	registerFunction( "soundex", new StandardSQLFunction("soundex") );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "ascii", new StandardSQLFunction("ascii", StandardBasicTypes.INTEGER) );

	registerFunction( "to_char", new StandardSQLFunction("to_char", StandardBasicTypes.STRING) );
	registerFunction( "to_date", new StandardSQLFunction("to_date", StandardBasicTypes.TIMESTAMP) );

	registerFunction( "current_date", new NoArgSQLFunction("current_date", StandardBasicTypes.DATE, false) );
	registerFunction( "current_time", new NoArgSQLFunction("current_timestamp", StandardBasicTypes.TIME, false) );
	registerFunction( "current_timestamp", new NoArgSQLFunction("current_timestamp", StandardBasicTypes.TIMESTAMP, false) );

	registerFunction( "last_day", new StandardSQLFunction("last_day", StandardBasicTypes.DATE) );
	registerFunction( "sysdate", new NoArgSQLFunction("sysdate", StandardBasicTypes.DATE, false) );
	registerFunction( "systimestamp", new NoArgSQLFunction("systimestamp", StandardBasicTypes.TIMESTAMP, false) );
	registerFunction( "uid", new NoArgSQLFunction("uid", StandardBasicTypes.INTEGER, false) );
	registerFunction( "user", new NoArgSQLFunction("user", StandardBasicTypes.STRING, false) );

	registerFunction( "rowid", new NoArgSQLFunction("rowid", StandardBasicTypes.LONG, false) );
	registerFunction( "rownum", new NoArgSQLFunction("rownum", StandardBasicTypes.LONG, false) );

	// Multi-param string dialect functions...
	registerFunction( "concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "", "||", "") );
	registerFunction( "instr", new StandardSQLFunction("instr", StandardBasicTypes.INTEGER) );
	registerFunction( "instrb", new StandardSQLFunction("instrb", StandardBasicTypes.INTEGER) );
	registerFunction( "lpad", new StandardSQLFunction("lpad", StandardBasicTypes.STRING) );
	registerFunction( "replace", new StandardSQLFunction("replace", StandardBasicTypes.STRING) );
	registerFunction( "rpad", new StandardSQLFunction("rpad", StandardBasicTypes.STRING) );
	registerFunction( "substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING) );
	registerFunction( "substrb", new StandardSQLFunction("substrb", StandardBasicTypes.STRING) );
	registerFunction( "translate", new StandardSQLFunction("translate", StandardBasicTypes.STRING) );

	registerFunction( "substring", new StandardSQLFunction( "substr", StandardBasicTypes.STRING ) );
	registerFunction( "locate", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "instr(?2,?1)" ) );
	registerFunction( "bit_length", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "vsize(?1)*8" ) );
	registerFunction( "coalesce", new NvlFunction() );

	// Multi-param numeric dialect functions...
	registerFunction( "atan2", new StandardSQLFunction("atan2", StandardBasicTypes.FLOAT) );
	registerFunction( "log", new StandardSQLFunction("log", StandardBasicTypes.INTEGER) );
	registerFunction( "mod", new StandardSQLFunction("mod", StandardBasicTypes.INTEGER) );
	registerFunction( "nvl", new StandardSQLFunction("nvl") );
	registerFunction( "nvl2", new StandardSQLFunction("nvl2") );
	registerFunction( "power", new StandardSQLFunction("power", StandardBasicTypes.FLOAT) );

	// Multi-param date dialect functions...
	registerFunction( "add_months", new StandardSQLFunction("add_months", StandardBasicTypes.DATE) );
	registerFunction( "months_between", new StandardSQLFunction("months_between", StandardBasicTypes.FLOAT) );
	registerFunction( "next_day", new StandardSQLFunction("next_day", StandardBasicTypes.DATE) );

	registerFunction( "str", new StandardSQLFunction("to_char", StandardBasicTypes.STRING) );
}

Source File: SAPDBDialect.java From lams with GNU General Public License v2.0

4 votes

/**
 * Constructs a SAPDBDialect
 */
public SAPDBDialect() {
	super();
	registerColumnType( Types.BIT, "boolean" );
	registerColumnType( Types.BIGINT, "fixed(19,0)" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.TINYINT, "fixed(3,0)" );
	registerColumnType( Types.INTEGER, "int" );
	registerColumnType( Types.CHAR, "char(1)" );
	registerColumnType( Types.VARCHAR, "varchar($l)" );
	registerColumnType( Types.FLOAT, "float" );
	registerColumnType( Types.DOUBLE, "double precision" );
	registerColumnType( Types.DATE, "date" );
	registerColumnType( Types.TIME, "time" );
	registerColumnType( Types.TIMESTAMP, "timestamp" );
	registerColumnType( Types.VARBINARY, "long byte" );
	registerColumnType( Types.NUMERIC, "fixed($p,$s)" );
	registerColumnType( Types.CLOB, "long varchar" );
	registerColumnType( Types.BLOB, "long byte" );

	registerFunction( "abs", new StandardSQLFunction( "abs" ) );
	registerFunction( "sign", new StandardSQLFunction( "sign", StandardBasicTypes.INTEGER ) );

	registerFunction( "exp", new StandardSQLFunction( "exp", StandardBasicTypes.DOUBLE ) );
	registerFunction( "ln", new StandardSQLFunction( "ln", StandardBasicTypes.DOUBLE ) );
	registerFunction( "log", new StandardSQLFunction( "ln", StandardBasicTypes.DOUBLE ) );
	registerFunction( "pi", new NoArgSQLFunction( "pi", StandardBasicTypes.DOUBLE ) );
	registerFunction( "power", new StandardSQLFunction( "power" ) );
	registerFunction( "acos", new StandardSQLFunction( "acos", StandardBasicTypes.DOUBLE ) );
	registerFunction( "asin", new StandardSQLFunction( "asin", StandardBasicTypes.DOUBLE ) );
	registerFunction( "atan", new StandardSQLFunction( "atan", StandardBasicTypes.DOUBLE ) );
	registerFunction( "cos", new StandardSQLFunction( "cos", StandardBasicTypes.DOUBLE ) );
	registerFunction( "cosh", new StandardSQLFunction( "cosh", StandardBasicTypes.DOUBLE ) );
	registerFunction( "cot", new StandardSQLFunction( "cos", StandardBasicTypes.DOUBLE ) );
	registerFunction( "sin", new StandardSQLFunction( "sin", StandardBasicTypes.DOUBLE ) );
	registerFunction( "sinh", new StandardSQLFunction( "sinh", StandardBasicTypes.DOUBLE ) );
	registerFunction( "tan", new StandardSQLFunction( "tan", StandardBasicTypes.DOUBLE ) );
	registerFunction( "tanh", new StandardSQLFunction( "tanh", StandardBasicTypes.DOUBLE ) );
	registerFunction( "radians", new StandardSQLFunction( "radians", StandardBasicTypes.DOUBLE ) );
	registerFunction( "degrees", new StandardSQLFunction( "degrees", StandardBasicTypes.DOUBLE ) );
	registerFunction( "atan2", new StandardSQLFunction( "atan2", StandardBasicTypes.DOUBLE ) );

	registerFunction( "round", new StandardSQLFunction( "round" ) );
	registerFunction( "trunc", new StandardSQLFunction( "trunc" ) );
	registerFunction( "ceil", new StandardSQLFunction( "ceil" ) );
	registerFunction( "floor", new StandardSQLFunction( "floor" ) );
	registerFunction( "greatest", new StandardSQLFunction( "greatest" ) );
	registerFunction( "least", new StandardSQLFunction( "least" ) );

	registerFunction( "time", new StandardSQLFunction( "time", StandardBasicTypes.TIME ) );
	registerFunction( "timestamp", new StandardSQLFunction( "timestamp", StandardBasicTypes.TIMESTAMP ) );
	registerFunction( "date", new StandardSQLFunction( "date", StandardBasicTypes.DATE ) );
	registerFunction( "microsecond", new StandardSQLFunction( "microsecond", StandardBasicTypes.INTEGER ) );

	registerFunction( "second", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "second(?1)" ) );
	registerFunction( "minute", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "minute(?1)" ) );
	registerFunction( "hour", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "hour(?1)" ) );
	registerFunction( "day", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "day(?1)" ) );
	registerFunction( "month", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "month(?1)" ) );
	registerFunction( "year", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "year(?1)" ) );

	registerFunction( "extract", new SQLFunctionTemplate( StandardBasicTypes.INTEGER, "?1(?3)" ) );

	registerFunction( "dayname", new StandardSQLFunction( "dayname", StandardBasicTypes.STRING ) );
	registerFunction( "monthname", new StandardSQLFunction( "monthname", StandardBasicTypes.STRING ) );
	registerFunction( "dayofmonth", new StandardSQLFunction( "dayofmonth", StandardBasicTypes.INTEGER ) );
	registerFunction( "dayofweek", new StandardSQLFunction( "dayofweek", StandardBasicTypes.INTEGER ) );
	registerFunction( "dayofyear", new StandardSQLFunction( "dayofyear", StandardBasicTypes.INTEGER ) );
	registerFunction( "weekofyear", new StandardSQLFunction( "weekofyear", StandardBasicTypes.INTEGER ) );

	registerFunction( "replace", new StandardSQLFunction( "replace", StandardBasicTypes.STRING ) );
	registerFunction( "translate", new StandardSQLFunction( "translate", StandardBasicTypes.STRING ) );
	registerFunction( "lpad", new StandardSQLFunction( "lpad", StandardBasicTypes.STRING ) );
	registerFunction( "rpad", new StandardSQLFunction( "rpad", StandardBasicTypes.STRING ) );
	registerFunction( "substr", new StandardSQLFunction( "substr", StandardBasicTypes.STRING ) );
	registerFunction( "initcap", new StandardSQLFunction( "initcap", StandardBasicTypes.STRING ) );
	registerFunction( "lower", new StandardSQLFunction( "lower", StandardBasicTypes.STRING ) );
	registerFunction( "ltrim", new StandardSQLFunction( "ltrim", StandardBasicTypes.STRING ) );
	registerFunction( "rtrim", new StandardSQLFunction( "rtrim", StandardBasicTypes.STRING ) );
	registerFunction( "lfill", new StandardSQLFunction( "ltrim", StandardBasicTypes.STRING ) );
	registerFunction( "rfill", new StandardSQLFunction( "rtrim", StandardBasicTypes.STRING ) );
	registerFunction( "soundex", new StandardSQLFunction( "soundex", StandardBasicTypes.STRING ) );
	registerFunction( "upper", new StandardSQLFunction( "upper", StandardBasicTypes.STRING ) );
	registerFunction( "ascii", new StandardSQLFunction( "ascii", StandardBasicTypes.STRING ) );
	registerFunction( "index", new StandardSQLFunction( "index", StandardBasicTypes.INTEGER ) );

	registerFunction( "value", new StandardSQLFunction( "value" ) );

	registerFunction( "concat", new VarArgsSQLFunction( StandardBasicTypes.STRING, "(", "||", ")" ) );
	registerFunction( "substring", new StandardSQLFunction( "substr", StandardBasicTypes.STRING ) );
	registerFunction( "locate", new StandardSQLFunction( "index", StandardBasicTypes.INTEGER ) );
	registerFunction( "coalesce", new StandardSQLFunction( "value" ) );

	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE );

}

Source File: Dialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

protected Dialect() {
	log.info( "Using dialect: " + this );
	sqlFunctions.putAll( STANDARD_AGGREGATE_FUNCTIONS );

	// standard sql92 functions (can be overridden by subclasses)
	registerFunction( "substring", new SQLFunctionTemplate( Hibernate.STRING, "substring(?1, ?2, ?3)" ) );
	registerFunction( "locate", new SQLFunctionTemplate( Hibernate.INTEGER, "locate(?1, ?2, ?3)" ) );
	registerFunction( "trim", new SQLFunctionTemplate( Hibernate.STRING, "trim(?1 ?2 ?3 ?4)" ) );
	registerFunction( "length", new StandardSQLFunction( "length", Hibernate.INTEGER ) );
	registerFunction( "bit_length", new StandardSQLFunction( "bit_length", Hibernate.INTEGER ) );
	registerFunction( "coalesce", new StandardSQLFunction( "coalesce" ) );
	registerFunction( "nullif", new StandardSQLFunction( "nullif" ) );
	registerFunction( "abs", new StandardSQLFunction( "abs" ) );
	registerFunction( "mod", new StandardSQLFunction( "mod", Hibernate.INTEGER) );
	registerFunction( "sqrt", new StandardSQLFunction( "sqrt", Hibernate.DOUBLE) );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "lower", new StandardSQLFunction("lower") );
	registerFunction( "cast", new CastFunction() );
	registerFunction( "extract", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(?1 ?2 ?3)") );

	//map second/minute/hour/day/month/year to ANSI extract(), override on subclasses
	registerFunction( "second", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(second from ?1)") );
	registerFunction( "minute", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(minute from ?1)") );
	registerFunction( "hour", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(hour from ?1)") );
	registerFunction( "day", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(day from ?1)") );
	registerFunction( "month", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(month from ?1)") );
	registerFunction( "year", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(year from ?1)") );

	registerFunction( "str", new SQLFunctionTemplate(Hibernate.STRING, "cast(?1 as char)") );

       // register hibernate types for default use in scalar sqlquery type auto detection
	registerHibernateType( Types.BIGINT, Hibernate.BIG_INTEGER.getName() );
	registerHibernateType( Types.BINARY, Hibernate.BINARY.getName() );
	registerHibernateType( Types.BIT, Hibernate.BOOLEAN.getName() );
	registerHibernateType( Types.CHAR, Hibernate.CHARACTER.getName() );
	registerHibernateType( Types.DATE, Hibernate.DATE.getName() );
	registerHibernateType( Types.DOUBLE, Hibernate.DOUBLE.getName() );
	registerHibernateType( Types.FLOAT, Hibernate.FLOAT.getName() );
	registerHibernateType( Types.INTEGER, Hibernate.INTEGER.getName() );
	registerHibernateType( Types.SMALLINT, Hibernate.SHORT.getName() );
	registerHibernateType( Types.TINYINT, Hibernate.BYTE.getName() );
	registerHibernateType( Types.TIME, Hibernate.TIME.getName() );
	registerHibernateType( Types.TIMESTAMP, Hibernate.TIMESTAMP.getName() );
	registerHibernateType( Types.VARCHAR, Hibernate.STRING.getName() );
	registerHibernateType( Types.VARBINARY, Hibernate.BINARY.getName() );
	registerHibernateType( Types.NUMERIC, Hibernate.BIG_DECIMAL.getName() );
	registerHibernateType( Types.DECIMAL, Hibernate.BIG_DECIMAL.getName() );
	registerHibernateType( Types.BLOB, Hibernate.BLOB.getName() );
	registerHibernateType( Types.CLOB, Hibernate.CLOB.getName() );
	registerHibernateType( Types.REAL, Hibernate.FLOAT.getName() );
}

Source File: SybaseDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

public SybaseDialect() {
	super();
	registerColumnType( Types.BIT, "tinyint" ); //Sybase BIT type does not support null values
	registerColumnType( Types.BIGINT, "numeric(19,0)" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.TINYINT, "tinyint" );
	registerColumnType( Types.INTEGER, "int" );
	registerColumnType( Types.CHAR, "char(1)" );
	registerColumnType( Types.VARCHAR, "varchar($l)" );
	registerColumnType( Types.FLOAT, "float" );
	registerColumnType( Types.DOUBLE, "double precision" );
	registerColumnType( Types.DATE, "datetime" );
	registerColumnType( Types.TIME, "datetime" );
	registerColumnType( Types.TIMESTAMP, "datetime" );
	registerColumnType( Types.VARBINARY, "varbinary($l)" );
	registerColumnType( Types.NUMERIC, "numeric($p,$s)" );
	registerColumnType( Types.BLOB, "image" );
	registerColumnType( Types.CLOB, "text" );

	registerFunction( "ascii", new StandardSQLFunction("ascii", Hibernate.INTEGER) );
	registerFunction( "char", new StandardSQLFunction("char", Hibernate.CHARACTER) );
	registerFunction( "len", new StandardSQLFunction("len", Hibernate.LONG) );
	registerFunction( "lower", new StandardSQLFunction("lower") );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "str", new StandardSQLFunction("str", Hibernate.STRING) );
	registerFunction( "ltrim", new StandardSQLFunction("ltrim") );
	registerFunction( "rtrim", new StandardSQLFunction("rtrim") );
	registerFunction( "reverse", new StandardSQLFunction("reverse") );
	registerFunction( "space", new StandardSQLFunction("space", Hibernate.STRING) );

	registerFunction( "user", new NoArgSQLFunction("user", Hibernate.STRING) );

	registerFunction( "current_timestamp", new NoArgSQLFunction("getdate", Hibernate.TIMESTAMP) );
	registerFunction( "current_time", new NoArgSQLFunction("getdate", Hibernate.TIME) );
	registerFunction( "current_date", new NoArgSQLFunction("getdate", Hibernate.DATE) );

	registerFunction( "getdate", new NoArgSQLFunction("getdate", Hibernate.TIMESTAMP) );
	registerFunction( "getutcdate", new NoArgSQLFunction("getutcdate", Hibernate.TIMESTAMP) );
	registerFunction( "day", new StandardSQLFunction("day", Hibernate.INTEGER) );
	registerFunction( "month", new StandardSQLFunction("month", Hibernate.INTEGER) );
	registerFunction( "year", new StandardSQLFunction("year", Hibernate.INTEGER) );
	registerFunction( "datename", new StandardSQLFunction("datename", Hibernate.STRING) );

	registerFunction( "abs", new StandardSQLFunction("abs") );
	registerFunction( "sign", new StandardSQLFunction("sign", Hibernate.INTEGER) );

	registerFunction( "acos", new StandardSQLFunction("acos", Hibernate.DOUBLE) );
	registerFunction( "asin", new StandardSQLFunction("asin", Hibernate.DOUBLE) );
	registerFunction( "atan", new StandardSQLFunction("atan", Hibernate.DOUBLE) );
	registerFunction( "cos", new StandardSQLFunction("cos", Hibernate.DOUBLE) );
	registerFunction( "cot", new StandardSQLFunction("cot", Hibernate.DOUBLE) );
	registerFunction( "exp", new StandardSQLFunction("exp", Hibernate.DOUBLE) );
	registerFunction( "log", new StandardSQLFunction( "log", Hibernate.DOUBLE) );
	registerFunction( "log10", new StandardSQLFunction("log10", Hibernate.DOUBLE) );
	registerFunction( "sin", new StandardSQLFunction("sin", Hibernate.DOUBLE) );
	registerFunction( "sqrt", new StandardSQLFunction("sqrt", Hibernate.DOUBLE) );
	registerFunction( "tan", new StandardSQLFunction("tan", Hibernate.DOUBLE) );
	registerFunction( "pi", new NoArgSQLFunction("pi", Hibernate.DOUBLE) );
	registerFunction( "square", new StandardSQLFunction("square") );
	registerFunction( "rand", new StandardSQLFunction("rand", Hibernate.FLOAT) );

	registerFunction("radians", new StandardSQLFunction("radians", Hibernate.DOUBLE) );
	registerFunction("degrees", new StandardSQLFunction("degrees", Hibernate.DOUBLE) );

	registerFunction( "round", new StandardSQLFunction("round") );
	registerFunction( "ceiling", new StandardSQLFunction("ceiling") );
	registerFunction( "floor", new StandardSQLFunction("floor") );

	registerFunction( "isnull", new StandardSQLFunction("isnull") );

	registerFunction( "concat", new VarArgsSQLFunction( Hibernate.STRING, "(","+",")" ) );

	registerFunction( "length", new StandardSQLFunction( "len", Hibernate.INTEGER ) );
	registerFunction( "trim", new SQLFunctionTemplate( Hibernate.STRING, "ltrim(rtrim(?1))") );
	registerFunction( "locate", new CharIndexFunction() );

	getDefaultProperties().setProperty(Environment.STATEMENT_BATCH_SIZE, NO_BATCH);
}

Source File: IngresDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

public IngresDialect() {
	super();
	registerColumnType( Types.BIT, "tinyint" );
	registerColumnType( Types.TINYINT, "tinyint" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.INTEGER, "integer" );
	registerColumnType( Types.BIGINT, "bigint" );
	registerColumnType( Types.REAL, "real" );
	registerColumnType( Types.FLOAT, "float" );
	registerColumnType( Types.DOUBLE, "float" );
	registerColumnType( Types.NUMERIC, "decimal($p, $s)" );
	registerColumnType( Types.DECIMAL, "decimal($p, $s)" );
	registerColumnType( Types.BINARY, 32000, "byte($l)" );
	registerColumnType( Types.BINARY, "long byte" );
	registerColumnType( Types.VARBINARY, 32000, "varbyte($l)" );
	registerColumnType( Types.VARBINARY, "long byte" );
	registerColumnType( Types.LONGVARBINARY, "long byte" );
	registerColumnType( Types.CHAR, "char(1)" );
	registerColumnType( Types.VARCHAR, 32000, "varchar($l)" );
	registerColumnType( Types.VARCHAR, "long varchar" );
	registerColumnType( Types.LONGVARCHAR, "long varchar" );
	registerColumnType( Types.DATE, "date" );
	registerColumnType( Types.TIME, "time with time zone" );
	registerColumnType( Types.TIMESTAMP, "timestamp with time zone" );
	registerColumnType( Types.BLOB, "blob" );
	registerColumnType( Types.CLOB, "clob" );

	registerFunction( "abs", new StandardSQLFunction( "abs" ) );
	registerFunction( "atan", new StandardSQLFunction( "atan", Hibernate.DOUBLE ) );
	registerFunction( "bit_add", new StandardSQLFunction( "bit_add" ) );
	registerFunction( "bit_and", new StandardSQLFunction( "bit_and" ) );
	registerFunction( "bit_length", new SQLFunctionTemplate( Hibernate.INTEGER, "octet_length(hex(?1))*4" ) );
	registerFunction( "bit_not", new StandardSQLFunction( "bit_not" ) );
	registerFunction( "bit_or", new StandardSQLFunction( "bit_or" ) );
	registerFunction( "bit_xor", new StandardSQLFunction( "bit_xor" ) );
	registerFunction( "character_length", new StandardSQLFunction( "character_length", Hibernate.LONG ) );
	registerFunction( "charextract", new StandardSQLFunction( "charextract", Hibernate.STRING ) );
	registerFunction( "concat", new VarArgsSQLFunction( Hibernate.STRING, "(", "+", ")" ) );
	registerFunction( "cos", new StandardSQLFunction( "cos", Hibernate.DOUBLE ) );
	registerFunction( "current_user", new NoArgSQLFunction( "current_user", Hibernate.STRING, false ) );
	registerFunction( "current_time", new NoArgSQLFunction( "date('now')", Hibernate.TIMESTAMP, false ) );
	registerFunction( "current_timestamp", new NoArgSQLFunction( "date('now')", Hibernate.TIMESTAMP, false ) );
	registerFunction( "current_date", new NoArgSQLFunction( "date('now')", Hibernate.TIMESTAMP, false ) );
	registerFunction( "date_trunc", new StandardSQLFunction( "date_trunc", Hibernate.TIMESTAMP ) );
	registerFunction( "day", new StandardSQLFunction( "day", Hibernate.INTEGER ) );
	registerFunction( "dba", new NoArgSQLFunction( "dba", Hibernate.STRING, true ) );
	registerFunction( "dow", new StandardSQLFunction( "dow", Hibernate.STRING ) );
	registerFunction( "extract", new SQLFunctionTemplate( Hibernate.INTEGER, "date_part('?1', ?3)" ) );
	registerFunction( "exp", new StandardSQLFunction( "exp", Hibernate.DOUBLE ) );
	registerFunction( "gmt_timestamp", new StandardSQLFunction( "gmt_timestamp", Hibernate.STRING ) );
	registerFunction( "hash", new StandardSQLFunction( "hash", Hibernate.INTEGER ) );
	registerFunction( "hex", new StandardSQLFunction( "hex", Hibernate.STRING ) );
	registerFunction( "hour", new StandardSQLFunction( "hour", Hibernate.INTEGER ) );
	registerFunction( "initial_user", new NoArgSQLFunction( "initial_user", Hibernate.STRING, false ) );
	registerFunction( "intextract", new StandardSQLFunction( "intextract", Hibernate.INTEGER ) );
	registerFunction( "left", new StandardSQLFunction( "left", Hibernate.STRING ) );
	registerFunction( "locate", new SQLFunctionTemplate( Hibernate.LONG, "locate(?1, ?2)" ) );
	registerFunction( "length", new StandardSQLFunction( "length", Hibernate.LONG ) );
	registerFunction( "ln", new StandardSQLFunction( "ln", Hibernate.DOUBLE ) );
	registerFunction( "log", new StandardSQLFunction( "log", Hibernate.DOUBLE ) );
	registerFunction( "lower", new StandardSQLFunction( "lower" ) );
	registerFunction( "lowercase", new StandardSQLFunction( "lowercase" ) );
	registerFunction( "minute", new StandardSQLFunction( "minute", Hibernate.INTEGER ) );
	registerFunction( "month", new StandardSQLFunction( "month", Hibernate.INTEGER ) );
	registerFunction( "octet_length", new StandardSQLFunction( "octet_length", Hibernate.LONG ) );
	registerFunction( "pad", new StandardSQLFunction( "pad", Hibernate.STRING ) );
	registerFunction( "position", new StandardSQLFunction( "position", Hibernate.LONG ) );
	registerFunction( "power", new StandardSQLFunction( "power", Hibernate.DOUBLE ) );
	registerFunction( "random", new NoArgSQLFunction( "random", Hibernate.LONG, true ) );
	registerFunction( "randomf", new NoArgSQLFunction( "randomf", Hibernate.DOUBLE, true ) );
	registerFunction( "right", new StandardSQLFunction( "right", Hibernate.STRING ) );
	registerFunction( "session_user", new NoArgSQLFunction( "session_user", Hibernate.STRING, false ) );
	registerFunction( "second", new StandardSQLFunction( "second", Hibernate.INTEGER ) );
	registerFunction( "size", new NoArgSQLFunction( "size", Hibernate.LONG, true ) );
	registerFunction( "squeeze", new StandardSQLFunction( "squeeze" ) );
	registerFunction( "sin", new StandardSQLFunction( "sin", Hibernate.DOUBLE ) );
	registerFunction( "soundex", new StandardSQLFunction( "soundex", Hibernate.STRING ) );
	registerFunction( "sqrt", new StandardSQLFunction( "sqrt", Hibernate.DOUBLE ) );
	registerFunction( "substring", new SQLFunctionTemplate( Hibernate.STRING, "substring(?1 FROM ?2 FOR ?3)" ) );
	registerFunction( "system_user", new NoArgSQLFunction( "system_user", Hibernate.STRING, false ) );
	//registerFunction( "trim", new StandardSQLFunction( "trim", Hibernate.STRING ) );
	registerFunction( "unhex", new StandardSQLFunction( "unhex", Hibernate.STRING ) );
	registerFunction( "upper", new StandardSQLFunction( "upper" ) );
	registerFunction( "uppercase", new StandardSQLFunction( "uppercase" ) );
	registerFunction( "user", new NoArgSQLFunction( "user", Hibernate.STRING, false ) );
	registerFunction( "usercode", new NoArgSQLFunction( "usercode", Hibernate.STRING, true ) );
	registerFunction( "username", new NoArgSQLFunction( "username", Hibernate.STRING, true ) );
	registerFunction( "uuid_create", new StandardSQLFunction( "uuid_create", Hibernate.BYTE ) );
	registerFunction( "uuid_compare", new StandardSQLFunction( "uuid_compare", Hibernate.INTEGER ) );
	registerFunction( "uuid_from_char", new StandardSQLFunction( "uuid_from_char", Hibernate.BYTE ) );
	registerFunction( "uuid_to_char", new StandardSQLFunction( "uuid_to_char", Hibernate.STRING ) );
	registerFunction( "year", new StandardSQLFunction( "year", Hibernate.INTEGER ) );
}

Source File: Oracle8iDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

protected void registerFunctions() {
	registerFunction( "abs", new StandardSQLFunction("abs") );
	registerFunction( "sign", new StandardSQLFunction("sign", Hibernate.INTEGER) );

	registerFunction( "acos", new StandardSQLFunction("acos", Hibernate.DOUBLE) );
	registerFunction( "asin", new StandardSQLFunction("asin", Hibernate.DOUBLE) );
	registerFunction( "atan", new StandardSQLFunction("atan", Hibernate.DOUBLE) );
	registerFunction( "cos", new StandardSQLFunction("cos", Hibernate.DOUBLE) );
	registerFunction( "cosh", new StandardSQLFunction("cosh", Hibernate.DOUBLE) );
	registerFunction( "exp", new StandardSQLFunction("exp", Hibernate.DOUBLE) );
	registerFunction( "ln", new StandardSQLFunction("ln", Hibernate.DOUBLE) );
	registerFunction( "sin", new StandardSQLFunction("sin", Hibernate.DOUBLE) );
	registerFunction( "sinh", new StandardSQLFunction("sinh", Hibernate.DOUBLE) );
	registerFunction( "stddev", new StandardSQLFunction("stddev", Hibernate.DOUBLE) );
	registerFunction( "sqrt", new StandardSQLFunction("sqrt", Hibernate.DOUBLE) );
	registerFunction( "tan", new StandardSQLFunction("tan", Hibernate.DOUBLE) );
	registerFunction( "tanh", new StandardSQLFunction("tanh", Hibernate.DOUBLE) );
	registerFunction( "variance", new StandardSQLFunction("variance", Hibernate.DOUBLE) );

	registerFunction( "round", new StandardSQLFunction("round") );
	registerFunction( "trunc", new StandardSQLFunction("trunc") );
	registerFunction( "ceil", new StandardSQLFunction("ceil") );
	registerFunction( "floor", new StandardSQLFunction("floor") );

	registerFunction( "chr", new StandardSQLFunction("chr", Hibernate.CHARACTER) );
	registerFunction( "initcap", new StandardSQLFunction("initcap") );
	registerFunction( "lower", new StandardSQLFunction("lower") );
	registerFunction( "ltrim", new StandardSQLFunction("ltrim") );
	registerFunction( "rtrim", new StandardSQLFunction("rtrim") );
	registerFunction( "soundex", new StandardSQLFunction("soundex") );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "ascii", new StandardSQLFunction("ascii", Hibernate.INTEGER) );
	registerFunction( "length", new StandardSQLFunction("length", Hibernate.LONG) );

	registerFunction( "to_char", new StandardSQLFunction("to_char", Hibernate.STRING) );
	registerFunction( "to_date", new StandardSQLFunction("to_date", Hibernate.TIMESTAMP) );

	registerFunction( "current_date", new NoArgSQLFunction("current_date", Hibernate.DATE, false) );
	registerFunction( "current_time", new NoArgSQLFunction("current_timestamp", Hibernate.TIME, false) );
	registerFunction( "current_timestamp", new NoArgSQLFunction("current_timestamp", Hibernate.TIMESTAMP, false) );

	registerFunction( "lastday", new StandardSQLFunction("lastday", Hibernate.DATE) );
	registerFunction( "sysdate", new NoArgSQLFunction("sysdate", Hibernate.DATE, false) );
	registerFunction( "systimestamp", new NoArgSQLFunction("systimestamp", Hibernate.TIMESTAMP, false) );
	registerFunction( "uid", new NoArgSQLFunction("uid", Hibernate.INTEGER, false) );
	registerFunction( "user", new NoArgSQLFunction("user", Hibernate.STRING, false) );

	registerFunction( "rowid", new NoArgSQLFunction("rowid", Hibernate.LONG, false) );
	registerFunction( "rownum", new NoArgSQLFunction("rownum", Hibernate.LONG, false) );

	// Multi-param string dialect functions...
	registerFunction( "concat", new VarArgsSQLFunction(Hibernate.STRING, "", "||", "") );
	registerFunction( "instr", new StandardSQLFunction("instr", Hibernate.INTEGER) );
	registerFunction( "instrb", new StandardSQLFunction("instrb", Hibernate.INTEGER) );
	registerFunction( "lpad", new StandardSQLFunction("lpad", Hibernate.STRING) );
	registerFunction( "replace", new StandardSQLFunction("replace", Hibernate.STRING) );
	registerFunction( "rpad", new StandardSQLFunction("rpad", Hibernate.STRING) );
	registerFunction( "substr", new StandardSQLFunction("substr", Hibernate.STRING) );
	registerFunction( "substrb", new StandardSQLFunction("substrb", Hibernate.STRING) );
	registerFunction( "translate", new StandardSQLFunction("translate", Hibernate.STRING) );

	registerFunction( "substring", new StandardSQLFunction( "substr", Hibernate.STRING ) );
	registerFunction( "locate", new SQLFunctionTemplate( Hibernate.INTEGER, "instr(?2,?1)" ) );
	registerFunction( "bit_length", new SQLFunctionTemplate( Hibernate.INTEGER, "vsize(?1)*8" ) );
	registerFunction( "coalesce", new NvlFunction() );

	// Multi-param numeric dialect functions...
	registerFunction( "atan2", new StandardSQLFunction("atan2", Hibernate.FLOAT) );
	registerFunction( "log", new StandardSQLFunction("log", Hibernate.INTEGER) );
	registerFunction( "mod", new StandardSQLFunction("mod", Hibernate.INTEGER) );
	registerFunction( "nvl", new StandardSQLFunction("nvl") );
	registerFunction( "nvl2", new StandardSQLFunction("nvl2") );
	registerFunction( "power", new StandardSQLFunction("power", Hibernate.FLOAT) );

	// Multi-param date dialect functions...
	registerFunction( "add_months", new StandardSQLFunction("add_months", Hibernate.DATE) );
	registerFunction( "months_between", new StandardSQLFunction("months_between", Hibernate.FLOAT) );
	registerFunction( "next_day", new StandardSQLFunction("next_day", Hibernate.DATE) );

	registerFunction( "str", new StandardSQLFunction("to_char", Hibernate.STRING) );
}

Source File: TeradataDialect.java From cacheonix-core with GNU Lesser General Public License v2.1

4 votes

/**
 * Constructor
 */
public TeradataDialect() {
	super();
	//registerColumnType data types
	registerColumnType( Types.NUMERIC, "NUMERIC($p,$s)" );
	registerColumnType( Types.DOUBLE, "DOUBLE PRECISION" );
	registerColumnType( Types.BIGINT, "NUMERIC(18,0)" );
	registerColumnType( Types.BIT, "BYTEINT" );
	registerColumnType( Types.TINYINT, "BYTEINT" );
	registerColumnType( Types.VARBINARY, "VARBYTE($l)" );
	registerColumnType( Types.BINARY, "BYTEINT" );
	registerColumnType( Types.LONGVARCHAR, "LONG VARCHAR" );
	registerColumnType( Types.CHAR, "CHAR(1)" );
	registerColumnType( Types.DECIMAL, "DECIMAL" );
	registerColumnType( Types.INTEGER, "INTEGER" );
	registerColumnType( Types.SMALLINT, "SMALLINT" );
	registerColumnType( Types.FLOAT, "FLOAT" );
	registerColumnType( Types.VARCHAR, "VARCHAR($l)" );
	registerColumnType( Types.DATE, "DATE" );
	registerColumnType( Types.TIME, "TIME" );
	registerColumnType( Types.TIMESTAMP, "TIMESTAMP" );
	registerColumnType( Types.BOOLEAN, "BYTEINT" );  // hibernate seems to ignore this type...
	registerColumnType( Types.BLOB, "BLOB" );
	registerColumnType( Types.CLOB, "CLOB" );

	registerFunction( "year", new SQLFunctionTemplate( Hibernate.INTEGER, "extract(year from ?1)" ) );
	registerFunction( "length", new SQLFunctionTemplate( Hibernate.INTEGER, "character_length(?1)" ) );
	registerFunction( "concat", new VarArgsSQLFunction( Hibernate.STRING, "(", "||", ")" ) );
	registerFunction( "substring", new SQLFunctionTemplate( Hibernate.STRING, "substring(?1 from ?2 for ?3)" ) );
	registerFunction( "locate", new SQLFunctionTemplate( Hibernate.STRING, "position(?1 in ?2)" ) );
	registerFunction( "mod", new SQLFunctionTemplate( Hibernate.STRING, "?1 mod ?2" ) );
	registerFunction( "str", new SQLFunctionTemplate( Hibernate.STRING, "cast(?1 as varchar(255))" ) );

	// bit_length feels a bit broken to me. We have to cast to char in order to
	// pass when a numeric value is supplied. But of course the answers given will
	// be wildly different for these two datatypes. 1234.5678 will be 9 bytes as
	// a char string but will be 8 or 16 bytes as a true numeric.
	// Jay Nance 2006-09-22
	registerFunction(
			"bit_length", new SQLFunctionTemplate( Hibernate.INTEGER, "octet_length(cast(?1 as char))*4" )
	);

	// The preference here would be
	//   SQLFunctionTemplate( Hibernate.TIMESTAMP, "current_timestamp(?1)", false)
	// but this appears not to work.
	// Jay Nance 2006-09-22
	registerFunction( "current_timestamp", new SQLFunctionTemplate( Hibernate.TIMESTAMP, "current_timestamp" ) );
	registerFunction( "current_time", new SQLFunctionTemplate( Hibernate.TIMESTAMP, "current_time" ) );
	registerFunction( "current_date", new SQLFunctionTemplate( Hibernate.TIMESTAMP, "current_date" ) );
	// IBID for current_time and current_date

	registerKeyword( "password" );
	registerKeyword( "type" );
	registerKeyword( "title" );
	registerKeyword( "year" );
	registerKeyword( "month" );
	registerKeyword( "summary" );
	registerKeyword( "alias" );
	registerKeyword( "value" );
	registerKeyword( "first" );
	registerKeyword( "role" );
	registerKeyword( "account" );
	registerKeyword( "class" );

	// Tell hibernate to use getBytes instead of getBinaryStream
	getDefaultProperties().setProperty( Environment.USE_STREAMS_FOR_BINARY, "false" );
	// No batch statements
	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, NO_BATCH );
}

org.hibernate.dialect.function.SQLFunctionTemplate Java Examples