public String quote( String identifier ) { return repository.connectionDelegate.getDatabaseMeta().quoteField( identifier ); }
public String quote( String identifier ) { return repositoryMeta.getConnection().quoteField( identifier ); }
/** * Builds the set statement for MERGE stmt MERGE INTO T1 USING SRC ON CONDITION WHEN MATCHED THEN UPDATE SET << * setstatement >> ie, "Col1" = "SRC"."Field1", "Col2" = "SRC"."Field2" */ private String buildMergeSetString() { boolean suppress_comma = true; StringBuffer sb = new StringBuffer(); // Iterate over fieldStreamForFields[] for ( int i = 0; i < fieldStreamForFields.length; i++ ) { // Only added to this clause if Update Y/N is true if ( insOrUptFlag[i] ) { // Add comma to all except the first row if ( suppress_comma == true ) { suppress_comma = false; } else { sb.append( "," ); } sb.append( databaseMeta.quoteField( fieldTableForFields[i] ) ); sb.append( " = " ); sb.append( databaseMeta.quoteField( SOURCE_TABLE_ALIAS ) ).append( "." ); sb.append( databaseMeta.quoteField( fieldStreamForFields[i] ) ); } } return sb.toString(); }
/** * Builds the match condition for MERGE stmt MERGE INTO T1 USING SRC ON <<matchCondition>> ie, "SRC"."Field1" = * "TGT"."Table1" AND "SRC"."Field2" = "SRC"."Table2" * * @return */ private String buildMatchCondition() { StringBuffer matchCondition = new StringBuffer( 300 ); if ( fieldStreamForKeys != null ) { for ( int i = 0; i < fieldStreamForKeys.length; i++ ) { // Only add AND for all subsequent conditions, but not the first if ( i > 0 ) { matchCondition.append( Const.CR + "AND " ); } // "SRC"."FieldStreamName" matchCondition.append( databaseMeta.quoteField( SOURCE_TABLE_ALIAS ) ); matchCondition.append( "." ); matchCondition.append( databaseMeta.quoteField( fieldStreamForKeys[i] ) ); matchCondition.append( " = " ); // "TGT"."TableName" matchCondition.append( databaseMeta.quoteField( TARGET_TABLE_ALIAS ) ); matchCondition.append( "." ); matchCondition.append( databaseMeta.quoteField( fieldTableForKeys[i] ) ); matchCondition.append( Const.CR ); } } return matchCondition.toString(); }
Object[] row = null; String jobtrans = job ? databaseMeta.quoteField( "JOBNAME" ) : databaseMeta.quoteField( "TRANSNAME" ); + databaseMeta.quoteField( "ENDDATE" ) + ", " + databaseMeta.quoteField( "DEPDATE" ) + ", " + databaseMeta.quoteField( "STARTDATE" ); sql += " FROM " + logtable; sql += " WHERE " + databaseMeta.quoteField( "ERRORS" ) + " = 0"; sql += " AND " + databaseMeta.quoteField( "STATUS" ) + " = 'end'"; sql += " AND " + jobtrans + " = ?"; sql += " ORDER BY " + databaseMeta.quoteField( "LOGDATE" ) + " DESC, " + databaseMeta.quoteField( "ENDDATE" ) + " DESC";
/** * Return SQL CREATION statement for a Table * * @param tableName The table to create * @throws KettleDatabaseException */ public String getDDLCreationTable( String tableName, RowMetaInterface fields ) throws KettleDatabaseException { String retval; // First, check for reserved SQL in the input row r... databaseMeta.quoteReservedWords( fields ); String quotedTk = databaseMeta.quoteField( null ); retval = getCreateTableStatement( tableName, fields, quotedTk, false, null, true ); return retval; }
public String getInsertStatement( String schemaName, String tableName, RowMetaInterface fields ) { StringBuilder ins = new StringBuilder( 128 ); String schemaTable = databaseMeta.getQuotedSchemaTableCombination( schemaName, tableName ); ins.append( "INSERT INTO " ).append( schemaTable ).append( " (" ); // now add the names in the row: for ( int i = 0; i < fields.size(); i++ ) { if ( i > 0 ) { ins.append( ", " ); } String name = fields.getValueMeta( i ).getName(); ins.append( databaseMeta.quoteField( name ) ); } ins.append( ") VALUES (" ); // Add placeholders... for ( int i = 0; i < fields.size(); i++ ) { if ( i > 0 ) { ins.append( ", " ); } ins.append( " ?" ); } ins.append( ')' ); return ins.toString(); }
/** * Returns an empty string as most databases do not support tablespaces. Subclasses can override this method to * generate the DDL. * * @param variables * variables needed for variable substitution. * @param databaseMeta * databaseMeta needed for it's quoteField method. Since we are doing variable substitution we need to meta * so that we can act on the variable substitution first and then the creation of the entire string that will * be retuned. * @param tablespace * tablespaceName name of the tablespace. * * @return String the TABLESPACE tablespaceName section of an Oracle CREATE DDL statement. */ @Override public String getTablespaceDDL( VariableSpace variables, DatabaseMeta databaseMeta, String tablespace ) { if ( !Utils.isEmpty( tablespace ) ) { return "TABLESPACE " + databaseMeta.quoteField( variables.environmentSubstitute( tablespace ) ); } else { return ""; } }
/** * Calculate the schema-table combination, usually this is the schema and table separated with a dot. (schema.table) * * @param schemaName * the schema-name or null if no schema is used. * @param tableName * the table name * @return the schemaname-tablename combination */ public String getQuotedSchemaTableCombination( String schemaName, String tableName ) { if ( !supportsSchemas() || Utils.isEmpty( schemaName ) ) { if ( Utils.isEmpty( getPreferredSchemaName() ) ) { return quoteField( environmentSubstitute( tableName ) ); // no need to look further } else { return databaseInterface.getSchemaTableCombination( quoteField( environmentSubstitute( getPreferredSchemaName() ) ), quoteField( environmentSubstitute( tableName ) ) ); } } else { return databaseInterface.getSchemaTableCombination( quoteField( environmentSubstitute( schemaName ) ), quoteField( environmentSubstitute( tableName ) ) ); } }
/** * Changes the names of the fields to their quoted equivalent if this is needed * * @param fields * The row of fields to change */ public void quoteReservedWords( RowMetaInterface fields ) { for ( int i = 0; i < fields.size(); i++ ) { ValueMetaInterface v = fields.getValueMeta( i ); v.setName( quoteField( v.getName() ) ); } }
public Long getNextBatchIdUsingLockTables( DatabaseMeta dbm, Database ldb, String schemaName, String tableName, String fieldName ) throws KettleDatabaseException { // The old way of doing things... Long rtn = null; // Make sure we lock that table to avoid concurrency issues String schemaAndTable = dbm.getQuotedSchemaTableCombination( schemaName, tableName ); ldb.lockTables( new String[] { schemaAndTable, } ); try { // Now insert value -1 to create a real write lock blocking the other // requests.. FCFS String sql = "INSERT INTO " + schemaAndTable + " (" + dbm.quoteField( fieldName ) + ") values (-1)"; ldb.execStatement( sql ); // Now this next lookup will stall on the other connections // rtn = ldb.getNextValue( null, schemaName, tableName, fieldName ); } finally { // Remove the -1 record again... String sql = "DELETE FROM " + schemaAndTable + " WHERE " + dbm.quoteField( fieldName ) + "= -1"; ldb.execStatement( sql ); ldb.unlockTables( new String[] { schemaAndTable, } ); } return rtn; }
public String getDDL( String tableName, RowMetaInterface fields, String tk, boolean use_autoinc, String pk, boolean semicolon ) throws KettleDatabaseException { String retval; // First, check for reserved SQL in the input row r... databaseMeta.quoteReservedWords( fields ); String quotedTk = tk != null ? databaseMeta.quoteField( tk ) : null; if ( checkTableExists( tableName ) ) { retval = getAlterTableStatement( tableName, fields, quotedTk, use_autoinc, pk, semicolon ); } else { retval = getCreateTableStatement( tableName, fields, quotedTk, use_autoinc, pk, semicolon ); } return retval; }
@Before public void setUp() throws Exception { databaseMeta = mock( DatabaseMeta.class ); doReturn( "" ).when( databaseMeta ).quoteField( anyString() ); tableOutputMeta = mock( TableOutputMeta.class ); doReturn( databaseMeta ).when( tableOutputMeta ).getDatabaseMeta(); stepMeta = mock( StepMeta.class ); doReturn( "step" ).when( stepMeta ).getName(); doReturn( mock( StepPartitioningMeta.class ) ).when( stepMeta ).getTargetStepPartitioningMeta(); doReturn( tableOutputMeta ).when( stepMeta ).getStepMetaInterface(); db = mock( Database.class ); doReturn( mock( Connection.class ) ).when( db ).getConnection(); tableOutputData = mock( TableOutputData.class ); tableOutputData.db = db; tableOutputData.tableName = "sas"; tableOutputData.preparedStatements = mock( Map.class ); tableOutputData.commitCounterMap = mock( Map.class ); TransMeta transMeta = mock( TransMeta.class ); doReturn( stepMeta ).when( transMeta ).findStep( anyString() ); tableOutput = new TableOutput( stepMeta, tableOutputData, 1, transMeta, mock( Trans.class ) ); tableOutput.setData( tableOutputData ); tableOutput.setMeta( tableOutputMeta ); tableOutputSpy = spy( tableOutput ); doReturn( stepMeta ).when( tableOutputSpy ).getStepMeta(); doReturn( false ).when( tableOutputSpy ).isRowLevel(); doReturn( false ).when( tableOutputSpy ).isDebug(); doNothing().when( tableOutputSpy ).logDetailed( anyString() ); }
public void truncateTable( String tablename ) throws KettleDatabaseException { if ( Utils.isEmpty( connectionGroup ) ) { String truncateStatement = databaseMeta.getTruncateTableStatement( null, tablename ); if ( truncateStatement == null ) { throw new KettleDatabaseException( "Truncate table not supported by " + databaseMeta.getDatabaseInterface().getPluginName() ); } execStatement( truncateStatement ); } else { execStatement( "DELETE FROM " + databaseMeta.quoteField( tablename ) ); } }
@Before public void setUp() throws Exception { databaseMeta = mock( DatabaseMeta.class ); doReturn( "" ).when( databaseMeta ).quoteField( anyString() );
/** * Checks the fields specified for reserved words and quotes them. * * @param fields * the list of fields to check * @return true if one or more values have a name that is a reserved word on this database type. */ public boolean replaceReservedWords( RowMetaInterface fields ) { boolean hasReservedWords = false; for ( int i = 0; i < fields.size(); i++ ) { ValueMetaInterface v = fields.getValueMeta( i ); if ( isReservedWord( v.getName() ) ) { hasReservedWords = true; v.setName( quoteField( v.getName() ) ); } } return hasReservedWords; }
DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); when( connectionDelegate.getDatabaseMeta() ).thenReturn( databaseMeta ); when( databaseMeta.quoteField( anyString() ) ).thenAnswer( new Answer<String>() { @Override public String answer( InvocationOnMock invocationOnMock ) throws Throwable { return "QUOTE_" + String.valueOf( invocationOnMock.getArguments()[ 0 ] + "_QUOTE" );
public String getDeleteStatement( RowMetaInterface rowMeta ) throws KettleDatabaseException { DatabaseMeta databaseMeta = meta.getDatabaseMeta(); data.deleteParameterRowMeta = new RowMeta(); String sql = "DELETE FROM " + data.realSchemaTable + Const.CR; sql += "WHERE "; for ( int i = 0; i < meta.getKeyLookup().length; i++ ) { if ( i != 0 ) { sql += "AND "; } sql += databaseMeta.quoteField( meta.getKeyLookup()[i] ); if ( "BETWEEN".equalsIgnoreCase( meta.getKeyCondition()[i] ) ) { sql += " BETWEEN ? AND ? "; data.deleteParameterRowMeta.addValueMeta( rowMeta.searchValueMeta( meta.getKeyStream()[i] ) ); data.deleteParameterRowMeta.addValueMeta( rowMeta.searchValueMeta( meta.getKeyStream2()[i] ) ); } else if ( "IS NULL".equalsIgnoreCase( meta.getKeyCondition()[i] ) || "IS NOT NULL".equalsIgnoreCase( meta .getKeyCondition()[i] ) ) { sql += " " + meta.getKeyCondition()[i] + " "; } else { sql += " " + meta.getKeyCondition()[i] + " ? "; data.deleteParameterRowMeta.addValueMeta( rowMeta.searchValueMeta( meta.getKeyStream()[i] ) ); } } return sql; }
sql += ", "; sql += databaseMeta.quoteField( meta.getUpdateLookup()[i] ); data.lookupReturnRowMeta.addValueMeta( rowMeta.searchValueMeta( meta.getUpdateStream()[i] ).clone() ); sql += " AND "; sql += databaseMeta.quoteField( meta.getKeyLookup()[i] ); if ( "BETWEEN".equalsIgnoreCase( meta.getKeyCondition()[i] ) ) { sql += " BETWEEN ? AND ? ";
sql += "AND "; sql += databaseMeta.quoteField( meta.getKeyLookup()[i] ); if ( "BETWEEN".equalsIgnoreCase( meta.getKeyCondition()[i] ) ) { sql += " BETWEEN ? AND ? ";