Java Code Examples for org.hibernate.dialect.function.SQLFunctionTemplate

The following examples show how to use org.hibernate.dialect.function.SQLFunctionTemplate. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: lams   Source File: Teradata14Dialect.java    License: GNU General Public License v2.0 6 votes vote down vote up
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 );
}
 
Example 2
Source Project: lams   Source File: SQLServerDialect.java    License: GNU General Public License v2.0 6 votes vote down vote up
/**
 * 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 );
}
 
Example 3
@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");
	}

}
 
Example 4
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");
}
 
Example 5
Source Project: oim-fx   Source File: SQLiteDialect.java    License: MIT License 5 votes vote down vote up
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));
}
 
Example 6
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));
}
 
Example 7
Source Project: lams   Source File: SybaseASE157Dialect.java    License: GNU General Public License v2.0 5 votes vote down vote up
/**
 * 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)" ) );
}
 
Example 8
Source Project: lams   Source File: InformixDialect.java    License: GNU General Public License v2.0 5 votes vote down vote up
/**
 * 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 );
}
 
Example 9
Source Project: MonitorClient   Source File: SQLiteDialect.java    License: Apache License 2.0 5 votes vote down vote up
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) );
}
 
Example 10
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"));
}
 
Example 11
Source Project: wangmarket   Source File: SQLiteDialect.java    License: Apache License 2.0 5 votes vote down vote up
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));
}
 
Example 12
@Override
public void contribute(MetadataBuilder metadataBuilder) {
    metadataBuilder.applySqlFunction(
            "date_trunc",
            new SQLFunctionTemplate(
                    StandardBasicTypes.TIMESTAMP,
                    "date_trunc('day', (?1 AT TIME ZONE ?2))"
            )
    );
}
 
Example 13
@Override
public void contribute(MetadataBuilder metadataBuilder) {
    metadataBuilder.applySqlFunction(
            "date_trunc",
            new SQLFunctionTemplate(
                    StandardBasicTypes.TIMESTAMP,
                    "date_trunc('day', (?1 AT TIME ZONE 'UTC'))"
            )
    );
}
 
Example 14
Source Project: webdsl   Source File: SQLiteDialect.java    License: Apache License 2.0 5 votes vote down vote up
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));
}
 
Example 15
Source Project: unitime   Source File: HibernateUtil.java    License: Apache License 2.0 5 votes vote down vote up
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"));
	}
}
 
Example 16
Source Project: unitime   Source File: HibernateUtil.java    License: Apache License 2.0 5 votes vote down vote up
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'"));
	}
}
 
Example 17
Source Project: poli-libras   Source File: SQLiteDialect.java    License: GNU General Public License v3.0 5 votes vote down vote up
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 ) );
}
 
Example 18
Source Project: butterfly   Source File: SQLiteDialect.java    License: Apache License 2.0 4 votes vote down vote up
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") );
}
 
Example 19
Source Project: lams   Source File: TeradataDialect.java    License: GNU General Public License v2.0 4 votes vote down vote up
/**
 * 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 );
}
 
Example 20
Source Project: lams   Source File: Oracle8iDialect.java    License: GNU General Public License v2.0 4 votes vote down vote up
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) );
}
 
Example 21
Source Project: lams   Source File: SAPDBDialect.java    License: GNU General Public License v2.0 4 votes vote down vote up
/**
 * 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 );

}
 
Example 22
public AbstractTransactSQLDialect() {
	super();
	registerColumnType( Types.BINARY, "binary($l)" );
	registerColumnType( Types.BIT, "tinyint" );
	registerColumnType( Types.BIGINT, "numeric(19,0)" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.TINYINT, "smallint" );
	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", StandardBasicTypes.INTEGER ) );
	registerFunction( "char", new StandardSQLFunction( "char", StandardBasicTypes.CHARACTER ) );
	registerFunction( "len", new StandardSQLFunction( "len", StandardBasicTypes.LONG ) );
	registerFunction( "lower", new StandardSQLFunction( "lower" ) );
	registerFunction( "upper", new StandardSQLFunction( "upper" ) );
	registerFunction( "str", new StandardSQLFunction( "str", StandardBasicTypes.STRING ) );
	registerFunction( "ltrim", new StandardSQLFunction( "ltrim" ) );
	registerFunction( "rtrim", new StandardSQLFunction( "rtrim" ) );
	registerFunction( "reverse", new StandardSQLFunction( "reverse" ) );
	registerFunction( "space", new StandardSQLFunction( "space", StandardBasicTypes.STRING ) );

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

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

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

	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( "cos", new StandardSQLFunction( "cos", StandardBasicTypes.DOUBLE ) );
	registerFunction( "cot", new StandardSQLFunction( "cot", StandardBasicTypes.DOUBLE ) );
	registerFunction( "exp", new StandardSQLFunction( "exp", StandardBasicTypes.DOUBLE ) );
	registerFunction( "log", new StandardSQLFunction( "log", StandardBasicTypes.DOUBLE ) );
	registerFunction( "log10", new StandardSQLFunction( "log10", StandardBasicTypes.DOUBLE ) );
	registerFunction( "sin", new StandardSQLFunction( "sin", StandardBasicTypes.DOUBLE ) );
	registerFunction( "sqrt", new StandardSQLFunction( "sqrt", StandardBasicTypes.DOUBLE ) );
	registerFunction( "tan", new StandardSQLFunction( "tan", StandardBasicTypes.DOUBLE ) );
	registerFunction( "pi", new NoArgSQLFunction( "pi", StandardBasicTypes.DOUBLE ) );
	registerFunction( "square", new StandardSQLFunction( "square" ) );
	registerFunction( "rand", new StandardSQLFunction( "rand", StandardBasicTypes.FLOAT ) );

	registerFunction( "radians", new StandardSQLFunction( "radians", StandardBasicTypes.DOUBLE ) );
	registerFunction( "degrees", new StandardSQLFunction( "degrees", StandardBasicTypes.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( StandardBasicTypes.STRING, "(", "+", ")" ) );

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

	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, NO_BATCH );
}
 
Example 23
Source Project: lams   Source File: PostgreSQL81Dialect.java    License: GNU General Public License v2.0 4 votes vote down vote up
/**
 * Constructs a PostgreSQL81Dialect
 */
public PostgreSQL81Dialect() {
	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.BINARY, "bytea" );
	registerColumnType( Types.LONGVARCHAR, "text" );
	registerColumnType( Types.LONGVARBINARY, "bytea" );
	registerColumnType( Types.CLOB, "text" );
	registerColumnType( Types.BLOB, "oid" );
	registerColumnType( Types.NUMERIC, "numeric($p, $s)" );
	registerColumnType( Types.OTHER, "uuid" );

	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( "cos", new StandardSQLFunction("cos", StandardBasicTypes.DOUBLE) );
	registerFunction( "cot", new StandardSQLFunction("cot", StandardBasicTypes.DOUBLE) );
	registerFunction( "exp", new StandardSQLFunction("exp", StandardBasicTypes.DOUBLE) );
	registerFunction( "ln", new StandardSQLFunction("ln", StandardBasicTypes.DOUBLE) );
	registerFunction( "log", new StandardSQLFunction("log", StandardBasicTypes.DOUBLE) );
	registerFunction( "sin", new StandardSQLFunction("sin", StandardBasicTypes.DOUBLE) );
	registerFunction( "sqrt", new StandardSQLFunction("sqrt", StandardBasicTypes.DOUBLE) );
	registerFunction( "cbrt", new StandardSQLFunction("cbrt", StandardBasicTypes.DOUBLE) );
	registerFunction( "tan", new StandardSQLFunction("tan", StandardBasicTypes.DOUBLE) );
	registerFunction( "radians", new StandardSQLFunction("radians", StandardBasicTypes.DOUBLE) );
	registerFunction( "degrees", new StandardSQLFunction("degrees", StandardBasicTypes.DOUBLE) );

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

	registerFunction( "random", new NoArgSQLFunction("random", StandardBasicTypes.DOUBLE) );
	registerFunction( "rand", new NoArgSQLFunction("random", 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( "lower", new StandardSQLFunction("lower") );
	registerFunction( "upper", new StandardSQLFunction("upper") );
	registerFunction( "substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING) );
	registerFunction( "initcap", new StandardSQLFunction("initcap") );
	registerFunction( "to_ascii", new StandardSQLFunction("to_ascii") );
	registerFunction( "quote_ident", new StandardSQLFunction("quote_ident", StandardBasicTypes.STRING) );
	registerFunction( "quote_literal", new StandardSQLFunction("quote_literal", StandardBasicTypes.STRING) );
	registerFunction( "md5", new StandardSQLFunction("md5", StandardBasicTypes.STRING) );
	registerFunction( "ascii", new StandardSQLFunction("ascii", StandardBasicTypes.INTEGER) );
	registerFunction( "char_length", new StandardSQLFunction("char_length", StandardBasicTypes.LONG) );
	registerFunction( "bit_length", new StandardSQLFunction("bit_length", StandardBasicTypes.LONG) );
	registerFunction( "octet_length", new StandardSQLFunction("octet_length", StandardBasicTypes.LONG) );

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

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

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

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

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

	getDefaultProperties().setProperty( Environment.STATEMENT_BATCH_SIZE, DEFAULT_BATCH_SIZE );
	getDefaultProperties().setProperty( Environment.NON_CONTEXTUAL_LOB_CREATION, "true" );
}
 
Example 24
Source Project: lams   Source File: Dialect.java    License: GNU General Public License v2.0 4 votes vote down vote up
protected Dialect() {
	LOG.usingDialect( this );
	StandardAnsiSqlAggregationFunctions.primeFunctionMap( sqlFunctions );

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

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

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

	registerColumnType( Types.BIT, "bit" );
	registerColumnType( Types.BOOLEAN, "boolean" );
	registerColumnType( Types.TINYINT, "tinyint" );
	registerColumnType( Types.SMALLINT, "smallint" );
	registerColumnType( Types.INTEGER, "integer" );
	registerColumnType( Types.BIGINT, "bigint" );
	registerColumnType( Types.FLOAT, "float($p)" );
	registerColumnType( Types.DOUBLE, "double precision" );
	registerColumnType( Types.NUMERIC, "numeric($p,$s)" );
	registerColumnType( Types.REAL, "real" );

	registerColumnType( Types.DATE, "date" );
	registerColumnType( Types.TIME, "time" );
	registerColumnType( Types.TIMESTAMP, "timestamp" );

	registerColumnType( Types.VARBINARY, "bit varying($l)" );
	registerColumnType( Types.LONGVARBINARY, "bit varying($l)" );
	registerColumnType( Types.BLOB, "blob" );

	registerColumnType( Types.CHAR, "char($l)" );
	registerColumnType( Types.VARCHAR, "varchar($l)" );
	registerColumnType( Types.LONGVARCHAR, "varchar($l)" );
	registerColumnType( Types.CLOB, "clob" );

	registerColumnType( Types.NCHAR, "nchar($l)" );
	registerColumnType( Types.NVARCHAR, "nvarchar($l)" );
	registerColumnType( Types.LONGNVARCHAR, "nvarchar($l)" );
	registerColumnType( Types.NCLOB, "nclob" );

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

	if(supportsPartitionBy()) {
		registerKeyword( "PARTITION" );
	}

	uniqueDelegate = new DefaultUniqueDelegate( this );
}
 
Example 25
public PostgreSQLDialect() {
	super();
	registerFunction("minute", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(minute from ?1)"));
	registerFunction("hour", new SQLFunctionTemplate(Hibernate.INTEGER, "extract(hour from ?1)"));
}
 
Example 26
/**
 * 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 );
}
 
Example 27
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) );
}
 
Example 28
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 ) );
}
 
Example 29
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);
}
 
Example 30
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);
}