void delete(Db db, Object obj) {
if (primaryKeyColumnNames == null || primaryKeyColumnNames.size() == 0) {
throw new IllegalStateException(
"No primary key columns defined "
+ "for table "
+ obj.getClass()
+ " - no update possible");
}
SQLStatement stat = new SQLStatement(db);
StatementBuilder buff = new StatementBuilder("DELETE FROM ");
buff.append(db.getDialect().getTableName(schemaName, tableName));
buff.resetCount();
Object alias = ClassUtils.newObject(obj.getClass());
Query<Object> query = Query.from(db, alias);
boolean firstCondition = true;
for (FieldDefinition field : fields) {
if (field.isPrimaryKey) {
Object aliasValue = field.getValue(alias);
Object value = field.getValue(obj);
if (!firstCondition) {
query.addConditionToken(ConditionAndOr.AND);
}
firstCondition = false;
query.addConditionToken(new Condition<Object>(aliasValue, value, CompareType.EQUAL));
}
}
stat.setSQL(buff.toString());
query.appendWhere(stat);
StatementLogger.delete(stat.getSQL());
stat.executeUpdate();
}
void initSelectObject(SelectTable<T> table, Object obj, Map<Object, SelectColumn<T>> map) {
for (FieldDefinition def : fields) {
def.initWithNewObject(obj);
SelectColumn<T> column = new SelectColumn<T>(table, def);
map.put(def.getValue(obj), column);
}
}
private int readNestedPosition(String fieldName, FieldType type) throws IOException {
String[] fieldNames = NESTED_FIELD_PATTERN.split(fieldName);
if (fieldNames.length > 1) {
FieldDefinition fd = null;
DefaultPortableReader reader = this;
for (int i = 0; i < fieldNames.length; i++) {
fd = reader.cd.getField(fieldNames[i]);
if (fd == null) {
break;
}
if (i == fieldNames.length - 1) {
break;
}
int pos = reader.readPosition(fd);
in.position(pos);
boolean isNull = in.readBoolean();
if (isNull) {
throw new NullPointerException("Parent field is null: " + fieldNames[i]);
}
reader = serializer.createReader(in, fd.getFactoryId(), fd.getClassId(), fd.getVersion());
}
if (fd == null) {
throw throwUnknownFieldException(fieldName);
}
if (fd.getType() != type) {
throw new HazelcastSerializationException("Not a '" + type + "' field: " + fieldName);
}
return reader.readPosition(fd);
}
throw throwUnknownFieldException(fieldName);
}
public Portable[] readPortableArray(String fieldName) throws IOException {
FieldDefinition fd = cd.getField(fieldName);
if (fd == null) {
throw throwUnknownFieldException(fieldName);
}
if (fd.getType() != FieldType.PORTABLE_ARRAY) {
throw new HazelcastSerializationException("Not a Portable array field: " + fieldName);
}
final int currentPos = in.position();
try {
int pos = readPosition(fd);
in.position(pos);
final int len = in.readInt();
final Portable[] portables = new Portable[len];
if (len > 0) {
final int offset = in.position();
for (int i = 0; i < len; i++) {
final int start = in.readInt(offset + i * 4);
in.position(start);
portables[i] =
serializer.readAndInitialize(in, fd.getFactoryId(), fd.getClassId(), fd.getVersion());
}
}
return portables;
} finally {
in.position(currentPos);
}
}
void readRow(Object item, ResultSet rs) {
for (int i = 0; i < fields.size(); i++) {
FieldDefinition def = fields.get(i);
Object o = def.read(rs, i + 1);
def.setValue(item, o);
}
}
/**
* Define a primary key by the specified column names.
*
* @param columnNames the ordered list of column names
*/
void setPrimaryKey(List<String> columnNames) {
primaryKeyColumnNames = New.arrayList(columnNames);
// set isPrimaryKey flag for all field definitions
for (FieldDefinition fieldDefinition : fieldMap.values()) {
fieldDefinition.isPrimaryKey =
this.primaryKeyColumnNames.contains(fieldDefinition.columnName);
}
}
<Y, X> void copyAttributeValues(Query<Y> query, X to, X map) {
for (FieldDefinition def : fields) {
Object obj = def.getValue(map);
SelectColumn<Y> col = query.getSelectColumn(obj);
Object value = col.getCurrentValue();
def.setValue(to, value);
}
}
public FieldDefinition getFieldByAlias(String alias) {
for (FactField factField : getFields()) {
FieldDefinition def = (FieldDefinition) factField;
if (def.resolveAlias().equals(alias)) {
return def;
}
}
return null;
}
public void setMaxLength(Object column, int maxLength) {
String columnName = getColumnName(column);
for (FieldDefinition f : fields) {
if (f.columnName.equals(columnName)) {
f.maxLength = maxLength;
break;
}
}
}
<Y, X> void appendSelectList(SQLStatement stat, Query<Y> query, X x) {
for (int i = 0; i < fields.size(); i++) {
if (i > 0) {
stat.appendSQL(", ");
}
FieldDefinition def = fields.get(i);
Object obj = def.getValue(x);
query.appendSQL(stat, obj);
}
}
public Widget createInstance() {
AggregateField aggregateField = new AggregateField(this);
Iterator fieldDefinitionIt = container.getWidgetDefinitions().iterator();
while (fieldDefinitionIt.hasNext()) {
FieldDefinition fieldDefinition = (FieldDefinition) fieldDefinitionIt.next();
aggregateField.addField((Field) fieldDefinition.createInstance());
}
return aggregateField;
}
private int readPosition(String fieldName, FieldType type) throws IOException {
if (raw) {
throw new HazelcastSerializationException(
"Cannot read Portable fields after getRawDataInput() is called!");
}
FieldDefinition fd = cd.getField(fieldName);
if (fd == null) {
return readNestedPosition(fieldName, type);
}
if (fd.getType() != type) {
throw new HazelcastSerializationException("Not a '" + type + "' field: " + fieldName);
}
return readPosition(fd);
}
/** Return a platform independant definition of the database table. */
public static TableDefinition tableDefinition(Session session) {
TableDefinition definition = TypeTester.tableDefinition();
FieldDefinition fieldDef;
definition.setName("BOOLEANS");
fieldDef = new FieldDefinition("BOOLEANV", Boolean.class);
fieldDef.setShouldAllowNull(false);
definition.addField(fieldDef);
fieldDef = new FieldDefinition("BOOLEANC", Boolean.class);
fieldDef.setShouldAllowNull(false);
definition.addField(fieldDef);
return definition;
}
/** initialize this definition with the other, sort of like a copy constructor */
public void initializeFrom(WidgetDefinition definition) throws Exception {
super.initializeFrom(definition);
if (definition instanceof AggregateFieldDefinition) {
AggregateFieldDefinition other = (AggregateFieldDefinition) definition;
this.combineExpr = other.combineExpr;
this.splitRegexp = other.splitRegexp;
this.splitPattern = other.splitPattern;
this.splitFailMessage = other.splitFailMessage;
Iterator defs = other.container.getWidgetDefinitions().iterator();
while (defs.hasNext()) {
container.addWidgetDefinition((WidgetDefinition) defs.next());
}
Collections.copy(this.splitMappings, other.splitMappings);
Iterator fields = other.mappedFields.iterator();
while (fields.hasNext()) {
this.mappedFields.add(fields.next());
}
} else {
throw new Exception(
"Definition to inherit from is not of the right type! (at " + getLocation() + ")");
}
}
public static void defineModel(String name, String... fields) {
JsArray<FieldDefinition> fieldsDefinition = JsArray.createArray().cast();
for (String s : fields) {
fieldsDefinition.push(FieldDefinition.create(s));
}
createModel(name, fieldsDefinition);
}
/** INTERNAL: Return the create type statement. */
public Writer buildCreationWriter(AbstractSession session, Writer writer)
throws ValidationException {
try {
writer.write("CREATE TYPE " + getFullName() + " AS OBJECT (");
for (Enumeration fieldsEnum = getFields().elements(); fieldsEnum.hasMoreElements(); ) {
FieldDefinition field = (FieldDefinition) fieldsEnum.nextElement();
field.appendTypeString(writer, session);
if (fieldsEnum.hasMoreElements()) {
writer.write(", ");
}
}
writer.write(")");
} catch (IOException ioException) {
throw ValidationException.fileError(ioException);
}
return writer;
}
@Override
public Void visitField(ClassDefinition classDefinition, FieldDefinition fieldDefinition) {
// print annotations first
for (AnnotationDefinition annotationDefinition : fieldDefinition.getAnnotations()) {
visitAnnotation(fieldDefinition, annotationDefinition);
}
// print field declaration
line()
.addAll(fieldDefinition.getAccess())
.add(fieldDefinition.getType().getJavaClassName())
.add(fieldDefinition.getName())
.add(";")
.print();
printLine();
return null;
}
private void registerClassDefinition(
ClassDefinition cd, Map<Integer, ClassDefinition> classDefMap, boolean checkClassDefErrors) {
for (int i = 0; i < cd.getFieldCount(); i++) {
FieldDefinition fd = cd.get(i);
if (fd.getType() == FieldType.PORTABLE || fd.getType() == FieldType.PORTABLE_ARRAY) {
int classId = fd.getClassId();
ClassDefinition nestedCd = classDefMap.get(classId);
if (nestedCd != null) {
((ClassDefinitionImpl) cd).addClassDef(nestedCd);
registerClassDefinition(nestedCd, classDefMap, checkClassDefErrors);
serializationContext.registerClassDefinition(nestedCd);
} else if (checkClassDefErrors) {
throw new HazelcastSerializationException(
"Could not find registered ClassDefinition for class-id: " + classId);
}
}
}
serializationContext.registerClassDefinition(cd);
}
protected void buildFields(ClassWriter cw, EnumClassDefinition classDef) {
FieldVisitor fv;
for (FieldDefinition fld : classDef.getFieldsDefinitions()) {
fv =
cw.visitField(
ACC_PRIVATE + ACC_FINAL,
fld.getName(),
BuildUtils.getTypeDescriptor(fld.getTypeName()),
null,
null);
fv.visitEnd();
}
{
fv =
cw.visitField(
ACC_PRIVATE + ACC_STATIC, "$context", "Lorg/mvel2/ParserContext;", null, null);
fv.visitEnd();
}
}
public static TableDefinition buildREADONLYCLASSTable() {
TableDefinition table = new TableDefinition();
table.setName("CMP3_XML_READONLY");
FieldDefinition fieldID = new FieldDefinition();
fieldID.setName("ID");
fieldID.setTypeName("NUMERIC");
fieldID.setSize(15);
fieldID.setSubSize(0);
fieldID.setIsPrimaryKey(true);
fieldID.setIsIdentity(true);
fieldID.setUnique(false);
fieldID.setShouldAllowNull(false);
table.addField(fieldID);
return table;
}
protected void setupDefinition(Element widgetElement, FieldDefinition definition)
throws Exception {
super.setupDefinition(widgetElement, definition);
// parse "@required"
boolean required = DomHelper.getAttributeAsBoolean(widgetElement, "required", false);
definition.setRequired(required);
// parse "@length"
int length = DomHelper.getAttributeAsInteger(widgetElement, "length", 7);
((CaptchaFieldDefinition) definition).setLength(length);
}
public static TableDefinition buildWHEELRIMTable() {
// CREATE TABLE JPA_OR_WHEEL_RIM (ID NUMBER(10) NOT NULL, PRIMARY KEY (ID))
TableDefinition table = new TableDefinition();
table.setName("JPA_OR_WHEEL_RIM");
FieldDefinition fieldID = new FieldDefinition();
fieldID.setName("ID");
fieldID.setTypeName("NUMERIC");
fieldID.setSize(10);
fieldID.setSubSize(0);
fieldID.setIsPrimaryKey(true);
fieldID.setIsIdentity(true);
fieldID.setShouldAllowNull(false);
fieldID.setUnique(false);
table.addField(fieldID);
return table;
}
public Portable readPortable(String fieldName) throws IOException {
FieldDefinition fd = cd.getField(fieldName);
if (fd == null) {
throw throwUnknownFieldException(fieldName);
}
if (fd.getType() != FieldType.PORTABLE) {
throw new HazelcastSerializationException("Not a Portable field: " + fieldName);
}
final int currentPos = in.position();
try {
int pos = readPosition(fd);
in.position(pos);
final boolean isNull = in.readBoolean();
if (!isNull) {
return serializer.readAndInitialize(
in, fd.getFactoryId(), fd.getClassId(), fd.getVersion());
}
return null;
} finally {
in.position(currentPos);
}
}
public static TableDefinition buildCACHEABLE_TRUE_ENTITYTable() {
TableDefinition table = new TableDefinition();
table.setName("XML_CACHEABLE_TRUE");
FieldDefinition fieldID = new FieldDefinition();
fieldID.setName("ID");
fieldID.setTypeName("NUMERIC");
fieldID.setSize(15);
fieldID.setShouldAllowNull(false);
fieldID.setIsPrimaryKey(true);
fieldID.setUnique(false);
fieldID.setIsIdentity(true);
table.addField(fieldID);
return table;
}
public TableDefinition buildUnderbossTable() {
TableDefinition table = new TableDefinition();
table.setName("JPA_UNDERBOSS");
FieldDefinition fieldID = new FieldDefinition();
fieldID.setName("ID");
fieldID.setTypeName("NUMERIC");
fieldID.setSize(15);
fieldID.setIsPrimaryKey(true);
fieldID.setIsIdentity(true);
fieldID.setUnique(false);
fieldID.setShouldAllowNull(false);
// fieldID.setForeignKeyFieldName("JPA_MAFIOSO.ID");
table.addField(fieldID);
return table;
}
/** Optionally truncates strings to the maximum length */
private static Object getValue(Object obj, FieldDefinition field) {
Object value = field.getValue(obj);
if (field.trimString && field.maxLength > 0) {
if (value instanceof String) {
// clip strings
String s = (String) value;
if (s.length() > field.maxLength) {
return s.substring(0, field.maxLength);
}
return s;
}
return value;
}
// standard behavior
return value;
}
/** checks completeness of this definition */
public void checkCompleteness() throws IncompletenessException {
super.checkCompleteness();
if (this.container.size() == 0)
throw new IncompletenessException("AggregateField doesn't have any child widgets!", this);
if (this.combineExpr == null)
throw new IncompletenessException("AggregateField requires a combine expression!", this);
if (this.splitPattern == null)
throw new IncompletenessException(
"AggregateField requires a split regular expression!", this);
if (this.splitMappings.size() == 0)
throw new IncompletenessException(
"AggregateField requires at least one group to field mapping!", this);
// now check children's completeness
List defs = container.getWidgetDefinitions();
Iterator it = defs.iterator();
while (it.hasNext()) {
((WidgetDefinition) it.next()).checkCompleteness();
}
}
public Block putStaticField(ParameterizedType target, FieldDefinition field) {
checkArgument(field.getAccess().contains(STATIC), "Field is not static: %s", field);
putStaticField(target, field.getName(), field.getType());
return this;
}
public Block putStaticField(FieldDefinition field) {
putStaticField(field.getDeclaringClass().getType(), field.getName(), field.getType());
return this;
}
public Block getStaticField(ParameterizedType target, FieldDefinition field) {
nodes.add(getStaticInstruction(target, field.getName(), field.getType()));
return this;
}
