Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.draagon.meta.manager.db.driver;
  
  import java.sql.ResultSet;
  import java.sql.Statement;
  
 
 
 public class DerbyDriver extends GenericSQLDriver 
 {
 	private static Log log = LogFactory.getLogDerbyDriver.class );

Creates a table in the database
 	
 	/*@Override
 	  public void createTable( Connection c, MetaClass mc )
 	  	throws MetaException
 	  {
 	      String table = null;
 
 	      try
 	      {
 	        table = (String) mc.getAttribute( ObjectManagerDB.TABLE_REF );
 
 	        String query = "CREATE TABLE " + table + "(\n";
 
 	        // Create the individual table fields
 	        int found = 0;
 	        Collection<MetaField> fields = mc.getMetaFields();
 	        for( MetaField mf : fields )
 	        {
 	          String name = getManager().getColumnName( mf );
 	          if ( name == null ) continue;
 
 	          if ( mf.hasAttribute( ObjectManagerDB.IS_READONLY )) continue;
 
 	          boolean isIdentity = false;
 	          //Collection keys = getManager().getPrimaryKeys( mc );
 	          if ( //keys.size() == 1 
 	        		  mf.hasAttribute( ObjectManager.AUTO )
 	        		  && mf.getAttribute( ObjectManager.AUTO )
 	        		  		.equals( ObjectManagerDB.AUTO_ID )) isIdentity = true;
 
 	          if ( found > 0 ) query += ",\n";
 	          found++;
 
 	          // Get the starting index for the table
 	          int startIndex = 1;
 	          if ( mf.hasAttribute( "dbIdentityStart" )) {
 	        	  startIndex = Integer.parseInt( (String) mf.getAttribute( "dbIdentityStart" ));
 	          }
 
 	          // Get the starting index for the table
 	          int increment = 1;
 	          if ( mf.hasAttribute( "dbIdentityIncrement" )) {
 	        	  startIndex = Integer.parseInt( (String) mf.getAttribute( "dbIdentityIncrement" ));
 	          }
 
 	          //if ( tmp[ i ].getSpecial() == Field.AUTONUM )
 	          //{
 	          //  query += "[" + name + "] [numeric](18,0) IDENTITY (1,1) PRIMARY KEY CLUSTERED NOT NULL";
 	          //}
 	          //else
 	          //{
 	            String flags = "";
 	            if ( getManager().isPrimaryKey( mf ))
 	            {
 	            	flags = "NOT NULL ";
 	            	if ( isIdentity ) flags += "GENERATED ALWAYS AS IDENTITY (START WITH " + startIndex + ", INCREMENT BY " + increment + ") ";
 	            }
 	            else if ( getManager().isUnique( mf )) flags = "NOT NULL UNIQUE ";
 	            //else if ( getManager().isIndex( mf )) flags = "NONCLUSTERED ";
 
 	            switch( mf.getType() )
 	            {
 	              case MetaField.BOOLEAN: query += "" + name + " smallint " + flags; break;
 	              case MetaField.BYTE: query += "" + name + " smallint " + flags; break;
 	              case MetaField.SHORT: query += "" + name + " smallint " + flags; break;
 	              case MetaField.INT: query += "" + name + " int " + flags; break;
 	              case MetaField.LONG: query += "" + name + " bigint " + flags; break;
 	              case MetaField.FLOAT: query += "" + name + " float " + flags; break;
 	              case MetaField.DOUBLE: query += "" + name + " decimal(19,4) " + flags; break;
 	              case MetaField.DATE: query += "" + name + " timestamp " + flags; break;
 	              case MetaField.STRING: query += "" + name + " varchar(" + mf.getLength() + ") " + flags; break;
 
 	              case MetaField.OBJECT:
 	                throw new MetaException( "In item [" + mf.getName() + "] the field [" + mf.getName() + "] is of type OBJECT which is not support for this database type" );
 
 	              default: continue;
 	            }
 	          }
 	        //}
 
 	        query += "\n)";
	        // This means there were no columns defined for the table
	        if ( found == 0 ) return;
	        log.debug( "(createTable) Creating table [" + table + "]: " + query );
	        Statement s = c.createStatement();
	        try {
	          s.execute( query );
	        } finally {  s.close(); }
	        // Create indexes
	        for( MetaField mf : fields )
	        {
	          String name = getManager().getColumnName( mf ); 
	          if ( name == null ) continue;
	          if ( !getManager().isPrimaryKey( mf )
	          		&& !getManager().isIndex( mf )) continue;
	          // Create the sequence
	          String query2 = "CREATE INDEX " + table + "_" + name + "_index ON " + table + "(" + name + ")";
	          log.debug( "(createIndex) Creating index for [" + mc.getName() + "] on field [" + mf.getName() + "]: " + query2 );
	          s = c.createStatement();
	          try { s.execute( query2 ); }
	          finally { s.close(); }
	        }
	        // WARNING:  Reimplement this to work with single auto keys
	        // query = "ALTER TABLE [" + table + "] WITH NOCHECK ADD\n" +
	        //        "CONSTRAINT [PK_" + table +"] PRIMARY KEY NONCLUSTERED ( [id] ) ON [PRIMARY]";
	        //s = c.createStatement();
	        //s.execute( query );
	        //s.close();
	      }
	      catch( Exception e )
	      {
	        //System.out.println( "LOGGER: " + getLogger() );
	        //System.out.println( "ITEM:   " + item );
	        //getLogger().log( ZONE, "createTable", Logger.ERROR, "Creation of table [" + item.getItemRef() + "] failed", e );
	        throw new MetaException( "Creation of table [" + table + "] failed", e );
	      }
		}*/

Creates a view in the database
	/*@Override
	    public void createView(Connection c, MetaClass mc) throws MetaException
	    {
		  String view = null;
	      view = (String) mc.getAttribute( ObjectManagerDB.VIEW_REF );
	      String sql = (String) mc.getAttribute( ObjectManagerDB.VIEW_SQL_REF );
	      String query = "CREATE VIEW " + view + " AS " + sql;
	      log.debug( "Creating view: " + query);
	      //ystem.out.println( ">>>> Creating View: " + query);
	      try
	      {
	            Statement s = c.createStatement();
	            try {
	                s.execute(query);
	            } finally {
	                s.close();
	            }
	       }
	       catch (Exception e) {
	            throw new MetaException( "Creation of view [" + view + "] failed [" + query + ": " + e.getMessage(), e );
	       }
	    } */

Creates the foreign keys for the table in the database
	/* @Override
		public void createForeignKeys( Connection c, MetaClass mc ) throws MetaException
		{
			for( ForeignKey fk : getManager().getForeignKeys( mc ))
			{
				String table = getManager().getTableName( mc );
				String col = getManager().getColumnName( fk.getField() );
				String foreignTable = getManager().getTableName( fk.getForeignClass() );
				String foreignCol = getManager().getColumnName( fk.getForeignField() );
	        	String fkstr = "fk_" + table + "_" + col;
	            String query = "ALTER TABLE " + table + ""
	            	+ " ADD CONSTRAINT " + fkstr + ""
	            	+ " FOREIGN KEY (" + col + ")"
	            	+ " REFERENCES " + foreignTable + " (" + foreignCol + ")";
	            log.debug( "Creating foreign key: " + query);
	            //ystem.out.println( ">>>> Creating foreign key: " + query);
	            try
	            {
		            Statement s = c.createStatement();
		            try {
		                s.execute(query);
		            } finally {
		                s.close();
		            }
		        }
		        catch (Exception e) {
		            throw new MetaException( "Creation of foreign key [" + fk + "] failed [" + query + "]: " + e.getMessage(), e );
		        }
			}
		}*/
	///**
	// * Returns whether the auto id is retrieved prior to creation
	// */
	//@Override
	//public int getAutoType() {
	//	return AUTO_POST;
	//}
Gets the next sequence for a given MetaClass
	private String getLastAutoIdConnection connColumnDef col ) throws SQLException
	{
		//String table = getManager().getTableName( mc );
		//if ( table == null )
		//	throw new MetaException( "MetaClass [" + mc + "] has no table defined" );
		//String col = getManager().getColumnName( mf );
		//if ( col == null )
		//	throw new MetaException( "MetaField [" + mf + "] has no column defined" );
		try
		{
			try
			{
				String query =
					"SELECT IDENTITY_VAL_LOCAL() " +
					"FROM " + getProperNamecol.getBaseTable().getNameDef() );
				ResultSet rs = s.executeQueryquery );
				try
				{
					if ( !rs.next() ) return "1";
					String tmp = rs.getString( 1 );
					if ( tmp == null ) return "1";
					int i = Integer.parseInttmp );
					return "" + i;
				}
				finally { rs.close(); }
			}
			finally { s.close(); }
		}
		catchSQLException e )
		{
			.error"Unable to get next id for column [" + col + "]: " + e.getMessage(), e );
			throw new SQLException"Unable to get next id for column [" + col + "]: " + e.getMessage(), e );
		}
	}

Gets the next sequence for a given MetaClass
	/*public synchronized String getNextFieldId( ObjectConnection c, MetaClass mc, MetaField mf )
			throws MetaException
		{
			//return "" + getNextSequence( getManager().getSequenceName( mf ));
			return super.getNextFieldId( c, mc, mf );
		}*/
	public String getDateFormat() {
		return "yyyy-MM-dd HH:mm:ss";
	}
	///////////////////////////////////////////////////////
	// TO STRING METHOD
	public String toString()
	{
		return "Derby Database Driver";
	}
New to GrepCode? Check out our FAQ X