mappingField.setName(sourceField.getName()); mappingField.setUseDelimiters(sourceField.shouldUseDelimiters()); mappingField.useUpperCaseForComparisons(sourceField.getUseUpperCaseForComparisons()); mappingField.setNameForComparisons(sourceField.getNameForComparisons()); mappingField.setNullable(sourceField.isNullable()); mappingField.setUpdatable(sourceField.isUpdatable()); mappingField.setInsertable(sourceField.isInsertable()); mappingField.setUnique(sourceField.isUnique()); mappingField.setScale(sourceField.getScale()); mappingField.setLength(sourceField.getLength()); mappingField.setPrecision(sourceField.getPrecision()); mappingField.setColumnDefinition(sourceField.getColumnDefinition()); if (sourceField.hasTableName()) { mappingField.setTable(clonedDescriptor.getTable(sourceField.getTable().getName())); mappingField.setIsTranslated(true);
DatabaseRecord recordWithValues= new DatabaseRecord(); recordWithValues.add(new DatabaseField("param1"), "someValue"); String sqlStringWithArgs = databaseQuery.getTranslatedSQLString(session, recordWithValues);
public DatabaseField(String fieldName, DatabaseTable databaseTable, String startDelimiter, String endDelimiter) { this.index = -1; this.sqlType = NULL_SQL_TYPE; setName(fieldName, startDelimiter, endDelimiter); this.table = databaseTable; initDDLFields(); }
private void setDatabaseFieldParameters(Session session, DatabaseField field) { if (session.getPlatform() instanceof PostgreSQLPlatform) { field.setSqlType(Types.OTHER); field.setType(UUID.class); } else { field.setSqlType(Types.VARCHAR); field.setType(String.class); } field.setColumnDefinition("UUID"); }
fieldDef.setName(dbField.getNameDelimited(databasePlatform)); if (dbField.getColumnDefinition() != null && dbField.getColumnDefinition().length() > 0) { fieldDef.setTypeDefinition(dbField.getColumnDefinition()); } else { Class fieldType = dbField.getType(); FieldTypeDefinition fieldTypeDef = (fieldType == null) ? null : databasePlatform.getFieldTypeDefinition(fieldType); if (dbField.getLength() > 0) { fieldDef.setSize(dbField.getLength()); } else if (dbField.getPrecision() > 0) { fieldDef.setSize(dbField.getPrecision()); fieldDef.setSubSize(dbField.getScale()); AbstractSessionLog.getLog().log(SessionLog.CONFIG, SessionLog.METADATA, "field_type_set_to_java_lang_string", dbField.getQualifiedName(), fieldType); fieldDef.setShouldAllowNull(dbField.isNullable()); fieldDef.setUnique(dbField.isUnique());
/** * PUBLIC: * Return the database column or query parameter to partition queries by. * This is the table column name, not the class attribute name. * The column value must be included in the query and should normally be part of the object's Id. * This can also be the name of a query parameter. * If a query does not contain the field the query will not be partitioned. */ public String getPartitionFieldName() { return getPartitionField().getName(); }
/** * PUBLIC: * This method should only be used with custom SQL: * it sets a type to IN, OUT or INOUT parameter (prefixed with #, ### or #### in custom SQL string). * The argumentFieldName is the field or argument name used in the SQL. * The type is the JDBC type code for the parameter. */ public void setCustomSQLArgumentType(String argumentFieldName, int type) { DatabaseField field = new DatabaseField(argumentFieldName); field.setSqlType(type); getParameters().add(field); getParameterTypes().add(null); }
@Override public void logDatabaseMapping(final DirectToFieldMapping databaseMapping, final Session session) { logFine(session, "\tmapping.attributeName : {0}", databaseMapping.getAttributeName()); logFine(session, "\tmapping.attributeClassification: {0}", databaseMapping.getAttributeClassification()); logFine(session, "\tmapping.field.name : {0}", databaseMapping.getField().getName()); logFine(session, "\tmapping.field.sqlType : {0}", databaseMapping.getField().getSqlType()); logFine(session, "\tmapping.field.typeName: {0}", databaseMapping.getField().getTypeName()); logFine(session, "\tmapping.field.columnDefinition : {0}", databaseMapping.getField().getColumnDefinition()); logFine(session, "\tmapping.fieldClassfication : {0}", databaseMapping.getFieldClassification()); }
/** * INTERNAL: * By calling this method we will return the foreign key field with the * extra metadata from the primary key field that can not be applied to a * referenced column. */ public DatabaseField getForeignKeyField(DatabaseField primaryKeyField) { // Initialize the DatabaseField with values and defaults. DatabaseField fkField = getForeignKeyField(); // Primary key field is null in variable one to one case. if (primaryKeyField != null) { fkField.setLength(primaryKeyField.getLength()); fkField.setPrecision(primaryKeyField.getPrecision()); fkField.setScale(primaryKeyField.getScale()); } return fkField; }
if (field.getType() == null) { if (transformer instanceof MethodBasedFieldTransformer) { field.setType(((MethodBasedFieldTransformer)transformer).getFieldType()); } else if (field.getColumnDefinition() != null) { while (iterator.hasNext()) { Map.Entry entry = (Map.Entry)iterator.next(); if (((FieldTypeDefinition)entry.getValue()).getName().equals(field.getColumnDefinition())) { field.setType((Class)entry.getKey()); break;
/** * entityDescからdataSetのカラム定義を生成します。 */ protected void setupAttributeColumns() { ServerSession serverSession = getEntityDesc().getServerSession(); ClassDescriptor cd = serverSession.getClassDescriptor(getEntityDesc().getEntityClass()); DatabasePlatform platform = serverSession.getPlatform(); for (DatabaseField field : cd.getFields()) { DataTable table = dataSet.getTable(field.getTableName()); int sqlType = platform.getJDBCType(field); String columnName = field.getName(); if (!table.hasColumn(columnName)) { table.addColumn(columnName, ColumnTypes.getColumnType(sqlType)); } } }
public DatabaseField buildField(DatabaseField field, DatabaseTable relationTable) { DatabaseField builtField = getObjectBuilder().getFieldsMap().get(field); if (builtField == null) { builtField = field; DatabaseTable table; if (relationTable != null && field.hasTableName() && field.getTableName().equals(relationTable.getName())){ table = relationTable; } else if (relationTable != null && !field.hasTableName()) { table = relationTable; } else if (field.hasTableName()) { table = getTable(field.getTableName()); } else { table = getDefaultTable(); } field.setTable(table); getObjectBuilder().getFieldsMap().put(builtField, builtField); } return builtField; }
/** * INTERNAL: * A DatabaseField is built from the given field name. */ // * added 9/7/00 by Les Davis // * bug fix for null pointer in initialization of mappings in remote session public DatabaseField buildField(String fieldName) { DatabaseField field = new DatabaseField(fieldName); DatabaseTable table; if (field.hasTableName()) { table = getTable(field.getTableName()); } else if (getDefaultTable() != null) { table = getDefaultTable(); } else { table = getTable(getTableName()); } field.setTable(table); return field; }
/** * INTERNAL: * Return the type of the map key, this will be overridden by container policies that allow maps * @return */ public Object getKeyType(){ return keyField.getType(); }
@Override public void initialize(DatabaseMapping mapping, Session session) { final DatabaseField field = mapping.getField(); field.setSqlType(java.sql.Types.OTHER); field.setTypeName("inet"); field.setColumnDefinition("INET"); } }
/** * PUBLIC: * Define the field name to be substitute for the function return. * The type is the type of Java class desired back from the function, this is dependent on the type returned from the function. */ public void setResult(String name, Class type) { DatabaseField returnField = (DatabaseField)getParameters().get(0); returnField.setName(name); returnField.setType(type); }
@Override public void customizeConverter(final DirectToFieldMapping databaseMapping, final Session session) { if (hasEnumTypeConverter(databaseMapping)) { final EnumTypeConverter eclipseConverter = (EnumTypeConverter) databaseMapping.getConverter(); final Class enumClazz = eclipseConverter.getEnumClass(); logFine(session, "Set enum-converter to field {0} with class {1}", databaseMapping.getField().getName(), enumClazz.getName()); databaseMapping.setConverter( new org.zalando.jpa.eclipselink.customizer.databasemapping.support.EnumTypeConverter(enumClazz, databaseMapping.getField().getColumnDefinition())); } }
/** * INTERNAL: * Those objects that need/want to initialize more meta data should * override this method. */ public DatabaseField getDatabaseField() { // Initialize the DatabaseField with values and defaults. DatabaseField databaseField = new DatabaseField(); //use the following method to manage delimited or case insensitive defaults setFieldName(databaseField, m_name == null ? "" : m_name); databaseField.setColumnDefinition(m_columnDefinition == null ? "" : m_columnDefinition); return databaseField; }