delete done

Author: rafaeluchoa

src/main/java/com/naskar/fluentquery/Delete.java

@@ -0,0 +1,11 @@
+package com.naskar.fluentquery;
+
+import com.naskar.fluentquery.impl.DeleteConverter;
+
+public interface Delete<T> extends Whereable<T, Delete<T>> {
+	
+	Class<T> getClazz();
+	
+	<E> E to(DeleteConverter<E> converter);
+
+}

src/main/java/com/naskar/fluentquery/DeleteBuilder.java

@@ -0,0 +1,11 @@
+package com.naskar.fluentquery;
+
+import com.naskar.fluentquery.impl.DeleteImpl;
+
+public class DeleteBuilder {
+
+	public <T> Delete<T> entity(Class<T> clazz) {
+		return new DeleteImpl<T>(clazz);
+	}
+
+}

src/main/java/com/naskar/fluentquery/converters/NativeSQLDelete.java

@@ -0,0 +1,83 @@
+package com.naskar.fluentquery.converters;
+
+import java.util.List;
+
+import com.naskar.fluentquery.conventions.SimpleConvention;
+import com.naskar.fluentquery.impl.Convention;
+import com.naskar.fluentquery.impl.DeleteConverter;
+import com.naskar.fluentquery.impl.DeleteImpl;
+import com.naskar.fluentquery.impl.DeleteParts;
+import com.naskar.fluentquery.impl.HolderInt;
+import com.naskar.fluentquery.impl.MethodRecordProxy;
+
+public class NativeSQLDelete implements DeleteConverter<NativeSQLResult> {
+	
+	private Convention convention;
+	private NativeSQLWhereImpl nativeWhereImpl;
+	
+	public NativeSQLDelete(Convention convention) {
+		this.convention = convention;
+		this.nativeWhereImpl = new NativeSQLWhereImpl();
+		this.nativeWhereImpl.setConvention(convention);
+	}
+	
+	public NativeSQLDelete() {
+		this(new SimpleConvention());
+	}
+	
+	public NativeSQLDelete setConvention(Convention convention) {
+		this.convention = convention;
+		this.nativeWhereImpl.setConvention(convention);
+		return this;
+	}
+		
+	@Override
+	public <T> NativeSQLResult convert(DeleteImpl<T> deleteImpl) {
+		
+		NativeSQLResult result = new NativeSQLResult();
+		
+		DeleteParts parts = new DeleteParts();
+		
+		HolderInt level = new HolderInt();
+		level.value = 0;
+		
+		convert(deleteImpl, parts, level, result, null);
+		
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append("delete from ");
+		sb.append(parts.getTable());
+		
+		if(parts.hasWhere()) {
+			sb.append(" where ");
+			sb.append(parts.getWhere());
+		}
+		
+		return result.sql(sb.toString());
+	}
+	
+	private <T> void convert(DeleteImpl<T> deleteImpl, DeleteParts parts, 
+			final HolderInt level, NativeSQLResult result, List<String> parents) {
+		MethodRecordProxy<T> proxy = new MethodRecordProxy<T>(createInstance(deleteImpl.getClazz()));
+		
+		String alias = "e" + level + ".";
+		
+		convertTable(parts.getTable(), alias, deleteImpl.getClazz());
+		
+		nativeWhereImpl.convertWhere(parts.getWhere(), alias, proxy, parents, deleteImpl.getPredicates(), result);		
+	}
+	
+	private <T> T createInstance(Class<T> clazz) {
+		try {
+			return clazz.newInstance();
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	private <T> void convertTable(StringBuilder sb, String alias, Class<T> clazz) {
+		sb.append(convention.getNameFromClass(clazz) + " " + 
+			alias.substring(0, alias.length()-1));
+	}
+	
+}

src/main/java/com/naskar/fluentquery/impl/DeleteConverter.java

@@ -0,0 +1,7 @@
+package com.naskar.fluentquery.impl;
+
+public interface DeleteConverter<E> {
+
+	<T> E convert(DeleteImpl<T> deleteImpl);
+
+}

src/main/java/com/naskar/fluentquery/impl/DeleteImpl.java

@@ -0,0 +1,26 @@
+package com.naskar.fluentquery.impl;
+
+import com.naskar.fluentquery.Delete;
+import com.naskar.fluentquery.converters.PredicateProvider;
+
+public class DeleteImpl<T>
+	extends WhereImpl<T, Delete<T>, DeleteImpl<T>> 
+	implements Delete<T>, PredicateProvider<T, DeleteImpl<T>> {
+	
+	private Class<T> clazz;
+
+	public DeleteImpl(Class<T> clazz) {
+		super(clazz);
+		this.clazz = clazz;
+	}
+	
+	public Class<T> getClazz() {
+		return clazz;
+	}
+	
+	@Override
+	public <E> E to(DeleteConverter<E> converter) {
+		return converter.convert(this);
+	}
+	
+}

src/main/java/com/naskar/fluentquery/impl/DeleteParts.java

@@ -0,0 +1,25 @@
+package com.naskar.fluentquery.impl;
+
+public class DeleteParts {
+	
+	private StringBuilder table;
+	private StringBuilder where;
+	
+	public DeleteParts() {
+		this.table = new StringBuilder("");
+		this.where = new StringBuilder("");
+	}
+	
+	public StringBuilder getTable() {
+		return table;
+	}
+
+	public StringBuilder getWhere() {
+		return where;
+	}
+	
+	public boolean hasWhere() {
+		return where.length() > 0;
+	}
+
+}

src/test/java/com/naskar/fluentquery/NativeDeleteTest.java

@@ -0,0 +1,41 @@
+package com.naskar.fluentquery;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.naskar.fluentquery.converters.NativeSQLDelete;
+import com.naskar.fluentquery.converters.NativeSQLResult;
+import com.naskar.fluentquery.domain.Customer;
+
+public class NativeDeleteTest {
+	
+	@Test
+	public void testDelete() {
+		String expected = "delete from Customer e0 where e0.id = :p0";
+		
+		NativeSQLResult result = new DeleteBuilder()
+			.entity(Customer.class)
+			.where(i -> i.getId()).eq(1L)
+			.to(new NativeSQLDelete());
+		
+		String actual = result.sql();
+		
+		Assert.assertEquals(expected, actual);
+		
+		Assert.assertEquals(result.params().get("p0"), 1L);
+	}
+	
+	@Test
+	public void testDeleteWithoutWhere() {
+		String expected = "delete from Customer e0";
+		
+		NativeSQLResult result = new DeleteBuilder()
+			.entity(Customer.class)
+			.to(new NativeSQLDelete());
+		
+		String actual = result.sql();
+		
+		Assert.assertEquals(expected, actual);
+	}
+	
+}

src/test/java/com/naskar/fluentquery/NativeMappingDeleteTest.java

@@ -0,0 +1,51 @@
+package com.naskar.fluentquery;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.naskar.fluentquery.conventions.MappingConvention;
+import com.naskar.fluentquery.converters.NativeSQLDelete;
+import com.naskar.fluentquery.converters.NativeSQLResult;
+import com.naskar.fluentquery.domain.Customer;
+import com.naskar.fluentquery.mapping.MappingFactory;
+
+public class NativeMappingDeleteTest {
+	
+	private MappingConvention mc;
+	
+	@Before
+	public void setup() {
+		mc = new MappingFactory().create();
+	}
+	
+	@Test
+	public void testDelete() {
+		String expected = "delete from TB_CUSTOMER e0 where e0.CD_CUSTOMER = :p0";
+		
+		NativeSQLResult result = new DeleteBuilder()
+			.entity(Customer.class)
+			.where(i -> i.getId()).eq(1L)
+			.to(new NativeSQLDelete(mc));
+		
+		String actual = result.sql();
+		
+		Assert.assertEquals(expected, actual);
+		
+		Assert.assertEquals(result.params().get("p0"), 1L);
+	}
+	
+	@Test
+	public void testDeleteWithoutWhere() {
+		String expected = "delete from TB_CUSTOMER e0";
+		
+		NativeSQLResult result = new DeleteBuilder()
+			.entity(Customer.class)
+			.to(new NativeSQLDelete(mc));
+		
+		String actual = result.sql();
+		
+		Assert.assertEquals(expected, actual);
+	}
+	
+}