br.ufrj.ppgi.greco.kettle.GraphTriplifyStep.tripleWriter(Object,Object[],GraphTriplifyStepData) - Code Metrics - johncurcio/ETL4LODPlus - Measure and Improve Code Quality continuously with Scrutinizer

tripleWriter(Object,Object[],GraphTriplifyStepData) D
last analyzed 2019-10-13 02:26 UTC

↳ Parent: br.ufrj.ppgi.greco.kettle.GraphTriplifyStep

Complexity

Conditions

Size

Total Lines	61
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
eloc	36
c	1
b	0
f	1
dl	0
loc	61
rs	4.2
cc	13

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like br.ufrj.ppgi.greco.kettle.GraphTriplifyStep.tripleWriter(Object,Object[],GraphTriplifyStepData) often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

package br.ufrj.ppgi.greco.kettle;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleStepException;
import org.pentaho.di.core.row.RowDataUtil;
import org.pentaho.di.core.row.RowMeta;
import org.pentaho.di.core.row.RowMetaInterface;
import org.pentaho.di.trans.Trans;
import org.pentaho.di.trans.TransMeta;
import org.pentaho.di.trans.step.BaseStep;
import org.pentaho.di.trans.step.StepDataInterface;
import org.pentaho.di.trans.step.StepInterface;
import org.pentaho.di.trans.step.StepMeta;
import org.pentaho.di.trans.step.StepMetaInterface;

/**
 * Step GraphTriplify.
 * <p />
 * 
 * @author Rogers Reiche de Mendonca
 * 
 */
public class GraphTriplifyStep extends BaseStep implements StepInterface {
	public GraphTriplifyStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta,
			Trans trans) {
		super(stepMeta, stepDataInterface, copyNr, transMeta, trans);
	}

	@Override
	public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
		if (super.init(smi, sdi)) {
			return true;
		} else
			return false;
	}

	@Override
	public void dispose(StepMetaInterface smi, StepDataInterface sdi) {
		super.dispose(smi, sdi);
	}

	/**
	 * Metodo chamado para cada linha que entra no step
	 */
	public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {

		GraphTriplifyStepMeta meta = (GraphTriplifyStepMeta) smi;
		GraphTriplifyStepData data = (GraphTriplifyStepData) sdi;

		// Obtem linha do fluxo de entrada e termina caso nao haja mais entrada
		Object[] row = getRow();
		if (row == null) { // Nao ha mais linhas de dados
			setOutputDone();
			return false;
		}

		// Executa apenas uma vez. Variavel first definida na superclasse com
		// valor true
		if (first) {
			first = false;

			// Obtem todas as colunas ateh o step anterior.
			// Chamar apenas apos chamar getRow()
			data.outputRowMeta = new RowMeta();

			// Adiciona os metadados do step atual
			meta.getFields(data.outputRowMeta, getStepname(), null, null, this);
		}

		// Logica do step
		// Leitura de campos Input
		RowMetaInterface rowMeta = getInputRowMeta();
		int indexGraph = rowMeta.indexOfValue(meta.getInputGraph());
		Object graph = (indexGraph >= 0) ? row[indexGraph] : null;

		// Set output row
		Method[] methods = graph.getClass().getMethods();
		boolean hasListStatements = false;
		for (Method method : methods) {
			if (method.getName().equals("listStatements")) {
				hasListStatements = true;
				break;
			}
		}

		if (hasListStatements) {
			tripleWriter(graph, null, data);
		}

		return true;
	}

	private int tripleWriter(Object model, Object[] row, GraphTriplifyStepData data) throws KettleStepException {
		int numPutRows = 0;

		// StmtIterator it = model.listStatements();
		// Testando usar reflexion
		Object it = null;
		try {
			it = model.getClass().getMethod("listStatements").invoke(model);
			if (it == null)
				return 0;

			// while (it.hasNext())
			while ((Boolean) it.getClass().getMethod("hasNext").invoke(it)) {
				// Statement stmt = it.next();
				Object stmt = it.getClass().getMethod("next").invoke(it);

				incrementLinesInput();

				// String subject = stmt.getSubject().toString();
				String subject = stmt.getClass().getMethod("getSubject").invoke(stmt).toString();
				// String predicate = stmt.getPredicate().toString();
				String predicate = stmt.getClass().getMethod("getPredicate").invoke(stmt).toString();
				// String object = stmt.getObject().toString();
				String object = stmt.getClass().getMethod("getObject").invoke(stmt).toString();

				if (subject != null && !subject.isEmpty() && predicate != null && !predicate.isEmpty()
						&& object != null) {
					// Monta linha com a tripla
					Object[] outputRow = row;
					int i = 0;
					outputRow = RowDataUtil.addValueData(outputRow, i++, subject);
					outputRow = RowDataUtil.addValueData(outputRow, i++, predicate);
					outputRow = RowDataUtil.addValueData(outputRow, i++, object);

					// Joga tripla no fluxo
					putRow(data.outputRowMeta, outputRow);

					numPutRows++;
				} else {
					String triplaIgnorada = stmt.getClass().getMethod("getString").invoke(stmt).toString();
					logBasic("Tripla ignorada: " + triplaIgnorada);
				}
			}
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return numPutRows;
	}
}


1		package br.ufrj.ppgi.greco.kettle;
2
3		import java.lang.reflect.InvocationTargetException;
4		import java.lang.reflect.Method;
5
6		import org.pentaho.di.core.exception.KettleException;
7		import org.pentaho.di.core.exception.KettleStepException;
8		import org.pentaho.di.core.row.RowDataUtil;
9		import org.pentaho.di.core.row.RowMeta;
10		import org.pentaho.di.core.row.RowMetaInterface;
11		import org.pentaho.di.trans.Trans;
12		import org.pentaho.di.trans.TransMeta;
13		import org.pentaho.di.trans.step.BaseStep;
14		import org.pentaho.di.trans.step.StepDataInterface;
15		import org.pentaho.di.trans.step.StepInterface;
16		import org.pentaho.di.trans.step.StepMeta;
17		import org.pentaho.di.trans.step.StepMetaInterface;
18
19		/**
20		* Step GraphTriplify.
21		* <p />
22		*
23		* @author Rogers Reiche de Mendonca
24		*
25		*/
26		public class GraphTriplifyStep extends BaseStep implements StepInterface {
27		public GraphTriplifyStep(StepMeta stepMeta, StepDataInterface stepDataInterface, int copyNr, TransMeta transMeta,
28		Trans trans) {
29		super(stepMeta, stepDataInterface, copyNr, transMeta, trans);
30		}
31
32		@Override
33		public boolean init(StepMetaInterface smi, StepDataInterface sdi) {
34		if (super.init(smi, sdi)) {
35		return true;
36		} else
37		return false;
38		}
39
40		@Override
41		public void dispose(StepMetaInterface smi, StepDataInterface sdi) {
42		super.dispose(smi, sdi);
43		}
44
45		/**
46		* Metodo chamado para cada linha que entra no step
47		*/
48	View Code Duplication	public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
		0 ignored issues – show Duplication introduced 2018-10-21 01:00 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
49		GraphTriplifyStepMeta meta = (GraphTriplifyStepMeta) smi;
50		GraphTriplifyStepData data = (GraphTriplifyStepData) sdi;
51
52		// Obtem linha do fluxo de entrada e termina caso nao haja mais entrada
53		Object[] row = getRow();
54		if (row == null) { // Nao ha mais linhas de dados
55		setOutputDone();
56		return false;
57		}
58
59		// Executa apenas uma vez. Variavel first definida na superclasse com
60		// valor true
61		if (first) {
62		first = false;
63
64		// Obtem todas as colunas ateh o step anterior.
65		// Chamar apenas apos chamar getRow()
66		data.outputRowMeta = new RowMeta();
67
68		// Adiciona os metadados do step atual
69		meta.getFields(data.outputRowMeta, getStepname(), null, null, this);
70		}
71
72		// Logica do step
73		// Leitura de campos Input
74		RowMetaInterface rowMeta = getInputRowMeta();
75		int indexGraph = rowMeta.indexOfValue(meta.getInputGraph());
76		Object graph = (indexGraph >= 0) ? row[indexGraph] : null;
77
78		// Set output row
79		Method[] methods = graph.getClass().getMethods();
80		boolean hasListStatements = false;
81		for (Method method : methods) {
82		if (method.getName().equals("listStatements")) {
83		hasListStatements = true;
84		break;
85		}
86		}
87
88		if (hasListStatements) {
89		tripleWriter(graph, null, data);
90		}
91
92		return true;
93		}
94
95		private int tripleWriter(Object model, Object[] row, GraphTriplifyStepData data) throws KettleStepException {
96		int numPutRows = 0;
97
98		// StmtIterator it = model.listStatements();
99		// Testando usar reflexion
100		Object it = null;
101		try {
102		it = model.getClass().getMethod("listStatements").invoke(model);
103		if (it == null)
104		return 0;
105
106		// while (it.hasNext())
107		while ((Boolean) it.getClass().getMethod("hasNext").invoke(it)) {
108		// Statement stmt = it.next();
109		Object stmt = it.getClass().getMethod("next").invoke(it);
110
111		incrementLinesInput();
112
113		// String subject = stmt.getSubject().toString();
114		String subject = stmt.getClass().getMethod("getSubject").invoke(stmt).toString();
115		// String predicate = stmt.getPredicate().toString();
116		String predicate = stmt.getClass().getMethod("getPredicate").invoke(stmt).toString();
117		// String object = stmt.getObject().toString();
118		String object = stmt.getClass().getMethod("getObject").invoke(stmt).toString();
119
120		if (subject != null && !subject.isEmpty() && predicate != null && !predicate.isEmpty()
121		&& object != null) {
122		// Monta linha com a tripla
123		Object[] outputRow = row;
124		int i = 0;
125		outputRow = RowDataUtil.addValueData(outputRow, i++, subject);
126		outputRow = RowDataUtil.addValueData(outputRow, i++, predicate);
127		outputRow = RowDataUtil.addValueData(outputRow, i++, object);
128
129		// Joga tripla no fluxo
130		putRow(data.outputRowMeta, outputRow);
131
132		numPutRows++;
133		} else {
134		String triplaIgnorada = stmt.getClass().getMethod("getString").invoke(stmt).toString();
135		logBasic("Tripla ignorada: " + triplaIgnorada);
136		}
137		}
138		} catch (IllegalAccessException e) {
139		// TODO Auto-generated catch block
140		e.printStackTrace();
141		} catch (IllegalArgumentException e) {
142		// TODO Auto-generated catch block
143		e.printStackTrace();
144		} catch (InvocationTargetException e) {
145		// TODO Auto-generated catch block
146		e.printStackTrace();
147		} catch (NoSuchMethodException e) {
148		// TODO Auto-generated catch block
149		e.printStackTrace();
150		} catch (SecurityException e) {
151		// TODO Auto-generated catch block
152		e.printStackTrace();
153		}
154
155		return numPutRows;
156		}
157		}
158

johncurcio / ETL4LODPlus

tripleWriter(Object,Object[],GraphTriplifyStepData) D last analyzed 2019-10-13 02:26 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like

tripleWriter(Object,Object[],GraphTriplifyStepData) D
last analyzed 2019-10-13 02:26 UTC