docs: public boolean create() throws DBException
      {
          boolean bSuccess = true;
          this.setResultSet(null, DBConstants.SQL_CREATE_TYPE);
          ResultSet resultSet = (ResultSet)this.getResultSet();
          if (resultSet == null)
          {
              Map<String,Object> properties = this.getDatabase().getProperties();
              String strAltSecondaryIndex = (String)this.getDatabase().getProperties().get(SQLParams.ALT_SECONDARY_INDEX);
              try   {
                  int iFirstIndex = 0;
                  Record record = this.getRecord();
                  StringBuilder sql = new StringBuilder();
                  sql.append("CREATE TABLE ");
                  sql.append(record.makeTableNames(true));
                  sql.append(" (");
                  for (int iIndex = 0; iIndex < record.getFieldCount(); iIndex++)
                  {
                      BaseField field = record.getField(iIndex);
                      if (field.isVirtual())
                          continue;
                      String strType = field.getSQLType(true, properties);
                      if (field instanceof CounterField)
                          if (this.getDatabase().isAutosequenceSupport())
                          {
                              String strCounterType = (String)this.getDatabase().getProperties().get(SQLParams.AUTO_SEQUENCE_TYPE);
                              if (strCounterType != null)
                                  strType = strCounterType;
                              String strAutoseqExtra = (String)this.getDatabase().getProperties().get(SQLParams.AUTO_SEQUENCE_EXTRA);
                              if (strAutoseqExtra != null)
                                  strType += strAutoseqExtra;
                              String strCounterExtra = (String)this.getDatabase().getProperties().get(SQLParams.COUNTER_EXTRA);
                              if (strCounterExtra != null)
                              {
                                  strType += strCounterExtra;
                                  iFirstIndex = 1;    // No need to build primary index
                              }
                          }
                      if (iIndex > 0)
                          sql.append(", ");
                      if (DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_NULL_KEY_SUPPORT)))
                          this.checkNullableKey(field, strAltSecondaryIndex != null); // Set the key to not nullable for create.
                      if (!field.isNullable())
                      	if (!DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_NULL_FIELD_SUPPORT)))	// Rare (or for locale dbs)
                      		strType += " NOT NULL";
                      if (strAltSecondaryIndex != null)
                          if (this.checkIndexField(field))
                              strType += ' ' + strAltSecondaryIndex;
                      sql.append(field.getFieldName(true, false)).append(' ').append(strType);
                  }
                  String strPrimaryKey = (String)this.getDatabase().getProperties().get(SQLParams.AUTO_SEQUENCE_PRIMARY_KEY);
                  if (strPrimaryKey != null)
                      if (record.getCounterField() != null)
                          if (this.getDatabase().isAutosequenceSupport())
                  {
                      sql.append(", ").append(strPrimaryKey).append(" (").append(record.getCounterField().getFieldName(true, false)).append(")");
                      iFirstIndex = 1;    // No need to build primary index
                  }
                  sql.append(")");
                  Utility.getLogger().info(sql.toString());
                  if (DBConstants.TRUE.equals((String)this.getDatabase().getProperties().get(SQLParams.NO_PREPARED_STATEMENTS_ON_CREATE)))
                      this.setStatement(null, DBConstants.SQL_CREATE_TYPE);
                  if (this.getStatement(DBConstants.SQL_CREATE_TYPE) == null)
                      this.setStatement(((JdbcDatabase)this.getDatabase()).getJDBCConnection().createStatement(), DBConstants.SQL_CREATE_TYPE);
                  this.getStatement(DBConstants.SQL_CREATE_TYPE).execute(sql.toString());
                  // Now set up the index(es)
                  sql = new StringBuilder();
                  String strPrimaryKeySQL = (String)this.getDatabase().getProperties().get(SQLParams.CREATE_PRIMARY_INDEX);
                  if (strPrimaryKeySQL == null)   // null=use default, If empty string, not supported.
                      strPrimaryKeySQL = "CREATE ${unique} INDEX ${keyname} ON ${table} (${fieldsandorder})";    // Default
                  String strCreateIndexSQL = (String)this.getDatabase().getProperties().get(SQLParams.CREATE_INDEX);
                  if (strCreateIndexSQL == null)   // null=use default, If empty string, not supported.
                      strCreateIndexSQL = strPrimaryKeySQL;    // Default
                  for (int iIndex = iFirstIndex; iIndex < record.getKeyAreaCount(); iIndex++)
                  {
                      KeyArea keyArea = record.getKeyArea(iIndex);
                      if ((keyArea.getUniqueKeyCode() == DBConstants.UNIQUE)
                          && (iIndex == iFirstIndex)
                              && (keyArea.getKeyFields() == 1))
                          sql = new StringBuilder(strPrimaryKeySQL);
                      else
                          sql = new StringBuilder(strCreateIndexSQL);
                      if (sql.length() == 0)
                          continue;   // Not supported.
                      boolean indexCanBeUnique = true;
                  	if (DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_NULL_UNIQUE_KEYS)))
                          if (iIndex > 0)
                      {	// This db considers null a valid index value and will throw a unique key error on write
                          for (int iFieldIndex = 0; iFieldIndex < keyArea.getKeyFields(); iFieldIndex++)
                          {
                              KeyField keyField = keyArea.getKeyField(iFieldIndex);
                              BaseField field = keyField.getField(DBConstants.FILE_KEY_AREA);
                              if (field.isNullable())
                              	indexCanBeUnique = false;
                          }
                      }
                      if (iIndex > 0)
                      	if (DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_NULL_FIELD_SUPPORT)))	// Rare (or for locale dbs)
                      		indexCanBeUnique = false;
                      
                      if ((keyArea.getUniqueKeyCode() == DBConstants.UNIQUE) && (indexCanBeUnique))
                          sql = Utility.replace(sql, "${unique}", "UNIQUE");
                      else
                          sql = Utility.replace(sql, "${unique}", DBConstants.BLANK);
                      String strKeyName = keyArea.getKeyName();
                      String strTableNames = record.makeTableNames(true);
                      if (DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_DUPLICATE_KEY_NAMES)))
                      {
                      	if (strTableNames.endsWith("_temp"))
                      		strKeyName = strTableNames.substring(0, strTableNames.length() - 5) + "_" + strKeyName;
                      	else
                      		strKeyName = strTableNames + "_" + strKeyName;
                      }
                      String strMaxKeyNameLength = (String)this.getDatabase().getProperties().get(SQLParams.MAX_KEY_NAME_LENGTH);
                      if (strMaxKeyNameLength != null)
                      {
                          int iMaxKeyNameLength = Integer.parseInt(strMaxKeyNameLength);
                          if (strKeyName.length() > iMaxKeyNameLength)
                          {
                          	strKeyName = strKeyName + (int)(Math.random() * 100000);
                              strKeyName = strKeyName.substring(strKeyName.length() - iMaxKeyNameLength);
                              while (!Character.isLetter(strKeyName.charAt(0))) {
                              	strKeyName = strKeyName.substring(1);
                              }
                          }
                      }
                      sql = Utility.replace(sql, "${keyname}", strKeyName);
                      sql = Utility.replace(sql, "${table}", strTableNames);
                      String strFields = DBConstants.BLANK;
                      String strFieldAndOrder = DBConstants.BLANK;
                      for (int iFieldIndex = 0; iFieldIndex < keyArea.getKeyFields(); iFieldIndex++)
                      {
                          KeyField keyField = keyArea.getKeyField(iFieldIndex);
                          BaseField field = keyField.getField(DBConstants.FILE_KEY_AREA);
                          if (iFieldIndex > 0)
                          {
                              strFields += ", ";
                              strFieldAndOrder += ", ";
                          }
                          strFields += field.getFieldName(true, false) + " ";
                          strFieldAndOrder += field.getFieldName(true, false) + " ";
                          if (keyField.getKeyOrder() == DBConstants.DESCENDING)
                              strFieldAndOrder += "DESC ";
                      }
                      sql = Utility.replace(sql, "${fields}", strFields);
                      sql = Utility.replace(sql, "${fieldsandorder}", strFieldAndOrder);
                      Utility.getLogger().info(sql.toString());
                      this.getStatement(DBConstants.SQL_CREATE_TYPE).execute(sql.toString());
                  }
              } catch (SQLException e)    {
                  throw this.getDatabase().convertError(e);
              } finally {
                  if (DBConstants.TRUE.equals(this.getDatabase().getProperties().get(SQLParams.NO_PREPARED_STATEMENTS_ON_CREATE)))
                      this.setStatement(null, DBConstants.SQL_CREATE_TYPE);
              }
          }
          this.setResultSet(null, DBConstants.SQL_CREATE_TYPE);
          return bSuccess;    // Success!!!
      }