Archiv der Kategorie: SAP

SAP Enterprise Portal: Deeplinks zu einer Portalseite

Problem

Möchte man eine Seite mit einem iView aufrufen, ist es meistens nötig die komplette Navigation bis zu diesem durchzuklicken. Das Portal besteht bei der Verwendung von iViews aus Frames.

Ansatz

Möchte man das SAP Enterprise Portal anweisen ein spezielles iView/eine spezielle Seite über einen Deeplink in den Frame zu laden, kann der folgende Trick genutzt werden.

Lösung

  1. Zunächst geht man auf die Portalseite, für die ein Deeplink benötight wird
  2. Zu die Adressleiste vom Browser gibt man javascript:void(prompt(„“,nodeid)); ein
  3. Der Deeplink setzt sich folgendermaßen zusammen: http://<hostname>:<port>/irj/portal?NavigationTarget=<javascript-result>

iView-Entwickler können den folgenden Code benutzen um Parameter über diesen Deeplink zu übergeben:

URL: http://firmenportalrechner.com:50000/irj/portal?NavigationTarget=navurl://885a76f8628af28c18d76773f98eaaaf&materialId=9380027

Java (z.B. iView): String materialId = (String) getPortalRequest().getServletRequest().getParameter(„materialId“);

VBA und SAP: Funktionsbausteine aufrufen

Aufgabenstellung

Die Aufgabenstellung sowie der Ansatz ist identisch mit diesem Artikel (Bitte zuerst lesen).

Prämissen / Vorraussetzungen

Die Datei librfc32.dll muss im VBA Editor eingebunden werden (sie ist nach der Installation der SAPGUI verfügbar).

Lösung

Aufbau der Verbindung

Public Function SAP_Logon(username As String, password As String) As Boolean
'*************************************************
'  ANMELDUNG AN SAP
'  ACHTUNG: USER MUSS BERECHTIGUNGEN HABEN!!!!
'*************************************************

    Set FunctionCtrl = CreateObject("SAP.Functions")
    'Objekt für die SAP Verbindung

    Set SapConnection = FunctionCtrl.Connection
   
    SapConnection.Client = "100"
    SapConnection.User = username
    SapConnection.Language = "DE"
    SapConnection.password = password
    
     SapConnection.hostname = "rechnername.firma.com" 'nicht das kuerzel wie DE9
    
    SapConnection.systemnumber = "0"

    If Not SapConnection.Logon(0, True) Then 'True silent - false offen
        MsgBox "Logon failed!!!", vbCritical
        CMS_Logon = False
    Else
        CMS_Logon = True
    End If
End Function

Abmelden

Public Function SAP_Logoff() As Boolean
    SapConnection.LogOff
End Function

Funktionbaustein befüllen und aufrufen

Public Function SAP_Create_Request() As Long
'******************************************************
'  Request erzeugen
'  Strukturen füllen und übergeben, dann Log ausgeben
'******************************************************

On Error GoTo ErrorMSG

    Dim FunctionModule As Object
    Dim e_EXPORTSTRUKTUR As Object
    Dim T_TABELLENSTRUKTUR As Object
    
    Dim te_messtab As Object
    
    Dim lCnt As Long

'   Assign Function Module
    Set FunctionModule = FunctionCtrl.Add("Z_FUBA")
    
'   Set export Variables
    Set e_EXPORTSTRUKTUR = FunctionModule.Exports("P_STRUKTURPARAMETER")

' Set structrue fields in export parameter
    e_EXPORTSTRUKTUR ("ZEXPORTPARAM1") = "BLA"
    e_EXPORTSTRUKTUR ("ZEXPORTPARAM1") = "BLA2"

    Set T_TABELLENSTRUKTUR  = FunctionModule.Tables("T_ZMMMATANF8")
    T_TABELLENSTRUKTUR.appendRow
    T_TABELLENSTRUKTUR(1, "SPALTE1") = 1
    T_TABELLENSTRUKTUR(1, "SPALTE2") = 2

    T_TABELLENSTRUKTUR.appendRow
    T_TABELLENSTRUKTUR(2, "SPALTE1") = 3
    T_TABELLENSTRUKTUR(2, "SPALTE2") = 4

'   Call Function Aufruf
    If FunctionModule.Call = True Then
        Set te_messtab = FunctionModule.Tables("TE_MESSTAB")
        ' Meldungen ausgeben:
        
        Dim intRow As Integer
        For intRow = 1 To te_messtab.RowCount
            If te_messtab(intRow, "ARBGB") = "ZMM0001" And _
                te_messtab(intRow, "MSGNR") = "003" Then

                ' ANForderung wurde erstellt.
                CMS_Create_Request = Val(te_messtab(intRow, "MSGV1"))
            End If
            Debug.Print te_messtab(intRow, "ARBGB")
            Debug.Print te_messtab(intRow, "MSGNR")
            Debug.Print te_messtab(intRow, "NATXT_DE")
            sMSGTXT = te_messtab(intRow, "NATXT_DE")
            Debug.Print te_messtab(intRow, "FLDNAME")
            Debug.Print te_messtab(intRow, "MSGV1")
            Debug.Print te_messtab(intRow, "MSGV2")
            Debug.Print te_messtab(intRow, "MSGV3")
            Debug.Print te_messtab(intRow, "MSGV4")
            Debug.Print "----------------------------------"
        Next
    Else
        CMS_Create_Request = 0
         MsgBox "Error creating the CMS Request." & vbNewLine & _
                "See Log for details", vbCritical
    End If
ErrorMSG:
  
End Function

Die Testfunktion

Public Sub Start()
'*************************************************
'  TESTUMGEBUNG
'*************************************************
    Dim RequestNo As Long
    Dim username As String
    Dim password As String
    
    username = "BJOERN"
    password = "ICHBINDERBESTE"
        
    Call CMS_Logon(username, password)
    RequestNo = SAP_Create_Request   
    Call CMS_Logoff
End Sub

SAP und JAVA: Zugriff auf Funktionsbausteine / BAPIs mit dem Java Connector

Aufgabenstellung

Es soll auf Daten aus dem SAP System zugegriffen werden, ohne die Datenbank direkt anzusprechen.

Ansatz

Durch die Verwendung des Java-Connectors (JCo) werden Funktionsbausteine / BAPIs als SAP Schnittstellen verwendet. Die Funktionsbausteine können über die SAP GUI mit dem BAPI-Explorer gesucht und mit der TA 37 getestet werden. Der nachfolgende Artikel beschäftigt sich mit dem Aufruf von einem Java-Server. Der JCo kann im Market Place von SAP kostenlos heruntergeladen werden.

Lösung

Remote Function Call (techn. RPC)

Ein Remote Function Call (RFC) ist die SAP-Implementierung von Remote Procedure Calls (RPC). Über einen RFC lassen sich Funktionsbausteine, bzw. BAPI’s aufrufen.

Ein RFC verwendet die Kommunikationsregeln des CPI-C-Protokolls, welches auf TCP/IP oder LU 6.2 basiert. LU 6.2 war dabei das Kommunikationsprotokoll von R/2-Mainframe-Systemen und wurde bei R/3 durch den einheitlichen TCP/IP-Standard ersetzt.

RFC’s nehmen ausschließlich Call-By-Value-Parameter entgegen, da die Übergabe von Zeigern und Speicheradressen hier keinen Sinn macht. In einem fremden System würde die Speicheradresse auf einen Speicher-Bereich zeigen, in dem keine oder Daten von anderen Anwendungen vorhanden sind.

Funktionsweise des Java Connectors (JCo)

Der Java Connector unterstützt den Aufruf von RFC’s, bzw. BAPIs aus einer externen Java-Umgebung (SAP-inbound-call), sowie den Aufruf externer JAVA-Funktionalitäten aus ABAP-Programmen heraus (SAP-outbound-call). Für die letztgenannte Variante existiert im Example-Verzeichnis des JCo ein Beispiel, in dem ein JCo-Server implementiert wird. Der JCo-Server muss dem SAP-System über die Transaktion SM59 bekanntgemacht werden.

Bei einem SAP-Inbound-Call ist die Vorgehensweise die folgende:

1.) Anmeldung der Java-Applikation am R/3-System

JCO.Client Conection = JCO.createClient(Mandant,
                                        Username,
                                        Password,
                                        Language,
                                        Hostname,
                                        Systemnummer);

Connection.connect();

2.) Herunterladen des Repository für den Funktionsbaustein

IRepository rep = JCO.createRepository("MyRepository", Connection);
IFunctionTemplate template = rep.getFunctionTemplate("BAPI_NAME");
JCO.Function funktion = new JCO.Function(template);

3.) Holen einer Referenz auf die Übergabeparameter

JCO.ParameterList import = funktion.getImportParameterList();
JCO.ParameterList table = funktion.getTableParameterList();

4.) Befüllen des Bausteins

5.) Funktionsbaustein ausführen

Connection.execute(funktion);

6.) Hole Referenz auf Rückgabeparameter

JCO.ParameterList export = funktion.getExportParameterList();
JCO.ParameterList table = funktion.getTableParameterList();

7.) Auslesen des Bausteins

Es werden synchrone (sRFC), asynchrone (aRFC) und transaktionale Aufrufe (tRFC, qRFC), sowie Connection-Pooling unterstützt (auf JAVA- wie auf ABAP-Seite).

SAP lobt zwar die Plattformunabhängigkeit des Connectors, jedoch stößt man bei einfachem Kopieren des Bytecodes auf Probleme, da hier eine plattformabhängige Bibliotheksdatei gekapselt wird, die bei höheren Releases nicht mehr funktioniert. Unter Windows wird die Datei librfc32.dll und unter Linux die Datei librfccm.so gekapselt.

Durch die Kapselung der Datei ist es ohne weiteres möglich, Konnektoren für nicht unterstützte Programmiersprachen zu implementieren.

Ein Tutorial der Zeitschrift „Der Entwickler“, welches Online zur Verfügung steht, zeigt durch Verwendung dieser Bibliothek, wie man Delphi an SAP-Systeme andocken kann. Der Artikel trägt den Namen „Delphi goes SAP“. Da es für Delphi keine Konnektoren wie den Java Connector gibt, ist die Kapselung dieser Datei notwendig.

Parameter von Funktionsbausteinen

Da die meisten SAP-Anwendungen im ABAP-Stack implementiert worden, greift man mit dem JAVA Connector hauptsächlich auf remotefähige Funktionsbausteine zu. Diesen werden entweder ausgefüllte Tabellen, oder Import-Parameter zur Verarbeitung übergeben. Als Ausgabe liefert ein Funktionsbaustein Fehler-Parameter, Export-Parameter, neue Tabellen oder auch die übergebenen Tabellen mit neuen Werten zurück. Hierfür ist es notwendig den syntaktischen Aufbau von JCO-Syntax zu kennen.

Import-Parameter

Import-Parameter kann man sich wie einfache Übergabeparametern aus bekannten Programmiersprachen vorstellen. Ein Import-Parameter entspricht einem Feld, was einen Datentyp beinhaltet (Char, Integer, String, Double…). Es kann keine Array’s, Listen oder Tabellen entgegennehmen.

SAP kennzeichnet hauseigene Funktionsbausteine mit einem vorangehenden I für „Import“. Mit der Transaktion SE16 ist es möglich sich die notwendigen Import-Parameter anzusehen.

Nicht alle Import-Parameter sind erforderlich, es gibt auch optionale Parameter. Nicht jeder Funktionsbaustein hat Import-Parameter.

Der nachstehende Code zeigt, wie mit Hilfe des JAVA Connectors der Funktionsbaustein „CFX_API_USER_GETDETAIL“, der die Detaildaten eines cFolders-Benutzers zurückgibt befüllt wird:

public String gibListeVonUsern()
{
  IRepository repository = JCO.createRepository("MYRepository", client);
  IFunctionTemplate ftemplate = repository
 .getFunctionTemplate("CFX_API_USER_GETDETAIL");
  Function func = ftemplate.getFunction();

  JCO.ParameterList input = func.getImportParameterList();
  input.setValue("KARPBJ01", "I_USER_ID");

  // Funktion aufrufen
  client.execute(func);
  (...)
}

Export-Parameter

Nachdem die Funktion ausgeführt wurde, kann über die Export-Parameter iteriert werden um die Rückgabewerte auszulesen. Dazu hat die Klasse ParameterList die Methode getFieldCount(), welche die Anzahl der Rückgabeparameter zurückliefert. Die Methode getString(index) ermöglich über den inkrementellen Index die Iteration mit einer Schleife. Dadurch lassen sich alle Parameter dynamisch auslesen.

Nachfolgend wird aus der aufgerufenden Funktion über die Export-Parameterliste iteriert und das Ergebnis an den String „informationen“ angehangen.


public String gibListeVonUsern()
{
  (...) //Hier war der Funktionsaufruf

  JCO.ParameterList output = func.getExportParameterList();

  for (int i = 0; i < output.getFieldCount(); i++)
  {
    informationen = informationen + output.getString(i) + "\n";
  }
  return informationen;
}

Changing-Parameter

Im Gegensatz zu Import- und Export-Parametern funktionieren Changing-Parameter in beide Richtungen (bidirektional). Der Aufruf ist dabei Call-By-Reference-ähnlich, da sich nach dem Ausführen des Funktionsbausteins mit dem Befehl client.execute(func); der Wert im Feld ändern kann. Das Befüllen und auslesen funktioniert dabei wie bei den Import- und Export-Parametern.

Table-Parameter

Table-Parameter sind bidirektional. Die Referenz auf eine Tabelle kann geholt werden, bevor die Funktion ausgeführt wurde. Hat man die Referenz auf die Tabelle, so lässt sich diese folgendermaßen befüllen:


  // Iteration über einen Vector
  for (int i = 0; i < vector.size(); i++)
  {
     // Neue Zeile an Tabelle anhängen und auf
     // neue Zeile wechseln
     table.appendRow();

     // schreibe in erste Spalte
     table.setValue((String)vector.get(i),0);

     // schreibe in zweite Spalte
     table.setValue((String)vector.get(i),1);
  }

Nachdem eine Funktion ausgeführt wurde, also nachdem Connection.execute(funktion); ausgeführt wurde, kann eine neue Tabelle zurückgeliefert werden, oder eine bereits befüllte Tabelle neue Werte beinhalten.

Um über eine Rückgabetabelle zu iterieren, gibt es die Funktion setRow(index). Das folgende Beispiel zeigt die Suche nach einem bestimmten String in der 3. Spalte und liefert das Feld „ID“ zurück:


  String rueckgabe = null;
  for (int i=0;i<outputtabelle.getNumRows();i++)
  {
    outputtabelle.setRow(i);

    if (outputtabelle.getString(2).equals(suche) )
    {
      rueckgabe = outputtabelle.getString("ID");
    }
  }

Wie ersichtlich wird, lässt sich die Spalte nicht nur anhand des inkrementellen Indexes ansprechen, sondern auch über den Spaltennamen.

In manchen Fällen ist es nötig eine eigene Tabelle zu erzeugen und diese an einen Funktionsbaustein zu übergeben. Zum Beispiel funktioniert die Zuweisung einer befüllten Ergebnistabelle an eine Übergabetabelle nicht, in diesem Fall muss man die Daten in einer Schleife einfach rauskopieren.

Eine eigene Tabellendefinition erzeugt man in diesem Fall so:


  JCO.MetaData smeta  = new JCO.MetaData("DIS");

  smeta.addInfo("DOKAR",  JCO.TYPE_STRING,  3,  0, 0);
  smeta.addInfo("DOKVR",  JCO.TYPE_STRING ,   2, 0, 0);
  smeta.addInfo("DOKTL",  JCO.TYPE_STRING ,   3, 0, 0);
  smeta.addInfo("DOKNR",  JCO.TYPE_STRING ,   3, 0, 0);

  JCO.Structure structure = new JCO.Structure(smeta); 
  JCO.Table table = new JCO.Table(structure);

Struktur-Parameter

Strukturen gehören zu den Tabellen-Typ-Parametern und sind Sonderfälle. Eine Struktur kann innerhalb einer Tabelle, in Import- oder Export-Parametern auftreten. Hierbei handelt es sich lediglich um eine weitere Aufteilung innerhalb eines einzigen Feldes.

Der folgende Code zeigt, wie eine Referenz auf eine Inputstruktur und auf einen normalen Import-Parameter geholt wird .


JCO.Structure struktur =
func.getImportParameterList().getStructure("SELECT_DOCUMENTDATA");
JCO.ParameterList inputdata = func.getImportParameterList();
struktur.setValue(art, "DOCUMENTTYPE");
inputdata.setValue("X", "GETCLASSIFICATION");
Output.execute(funktion);

Fortsetzung folgt …

Kostenloses Tool um SAP Rollen zu vergleichen / SAP Role Compare

Problemfeldbeschreibung

In großen Unternehmen sind die einzelnen Businessabteilungen so organisiert, dass die IT-Schnittstelle über eine Person mit IT-Background realisiert wird, diese jedoch nicht zwangsläufig von der IT gestellt wird. Hierbei kann es sich um eine „ehrenamtliche“ Tätigkeit handeln, die nichts mit der Hauptaufgabe des IT-Koordinators zu tun hat.

Die Koordinatoren besitzen besondere Rechte für die Vergabe von Rollen in der Transaktion SU01, welche auf bestimmte Länder oder Anwendungen begrenzt wird und den jeweiligen Businessbereich abdeckt.

Bei einem großem unübersichtlichen Rollenaufkommen bleibt den IT-Koordinatoren nur der Vergleich von Rollen, um herauszufinden welche Berechtigungen jemand benötigt oder welche ihm weggenommen werden sollen.

Aufgabenstellungen

Die Sachbearbeiter kommen zu den IT-Koordinatoren und diese bekommen dann die folgenden Frage- und Aufgabenstellungen

  • Die Person x benötigt die gleichen Berechtigungen auf Transaktion y wie die Person z hat.
  • Die Person x benötigt zusätzlich (alte Rechte bleiben erhalten) alle Berechtigungen im Testsystem, die sie im Produktivsystem hat
  • Die Person x braucht zusätzlich (alte Rechte bleiben erhalten) die gleichen Berechtigungen wie Person z.
  • u.v.m….

Anhand der Vielfalt von Fragestellungen stellen sich jetzt dem IT-Koordinator die folgenden Fragen

  • Welche Rollen hat die Person z an der Transaktion y, die Person x nicht hat?
  • Welche Rollen hat die Person x im Testsystem, die sie nicht im Produktivsystem hat?
  • Welche Rollen hat Person x die Person z nicht hat?
  • u.v.m. …

Ansatz

Die einzige Möglichkeit die dem Koordinator bleibt ist der Vergleich von Rollen zu Transaktionen über die Transaktion SUIM (Infosystem). Damit lassen sich die o.g. Anwendungsfälle alleine nicht abdecken. Vielmehr bietet die Transaktion die Möglichkeit eine Liste von Rollen

  • … nach Transaktionszuordnung
  • … nach Benutzerzuordnung
  • u.v.m. …

abzufragen. Diese Rollen müssten „händisch“ verglichen werden. Bei kryptischen Rollennamen nach dem Prinzip „CA_XXXX_LE44_MB“ und einer Anzahl von 200 Rollen pro Person oder Transaktion, artet das für eine „ehrenamtliche“ Tätigkeit in viel Arbeit aus.

Lösung

Vorgehensweise

Um diesen Vorgang wesentlich effizienter und effektiver zu gestalten, kann man die kostenlose Web-Anwendung (Flash) „Sap Role Compare“ benutzen. Hierbei ist die Vorgehensweise die folgende.

1.) Transkation SUIM aufrufen
2.) Die gewünschte Liste (z.B. Rollen nach Transaktionszuordnung) wählen
3.) Benutzer/Transaktion auswählen und auf die Uhr mit dem grünen Häkchen links oben klicken
4.) Wichtig: In der Ergebnisliste mit der Scrollleiste rechts GANZ RUNTER scrollen (sonst kommen die Daten nur teilweise in die Zwischenablage)
5.) Auf die Kopfzeile der Spalte klicken, in der die Rollennamen stehen, so dass ALLE Rollennamen selektiert sind.
6.) Rechte Maustaste->kopieren und im ersten Feld links der Webanwendung (Rollen (x) ) mit rechte Maustaste->einfügen (jetzt hätten wir alle Rollen der Transaktion, falls nach Transaktionname ausgewählt wurde).
7.) Wieder in SUIM den Benutzer/ die Transaktion auswählen, mit der verglichen werden soll (wir hätten jetzt die Rollen der Transaktion im ersten Feld (Rollen (x)) und kopieren ins zweite Feld (Rollen (z) )  die Rollen des Benutzers)
8.) Wieder ganz runter scrollen (nie vergessen), Spalte markieren, Rechte Maustaste->Kopieren und in Rollen(z) einfügen
9.) Den Button mit dem GLEICH-Zeichen klicken

Ergebnis

Wir erhalten jetzt 3 Ergebnismengen:

1.) Die Rollen, die in Rollen (x) und in Rollen (z) gleich sind
2.) Die Rollen, die in Rollen (x) und NICHT in Rollen (z)  sind
3.) Die Rollen, die in Rollen (z) und NICHT in Rollen (x)  sind

Mit diesen Mengen lassen sich ALLE Anwendungsfälle abdecken, die nicht durch die Transaktion SUIM unterstützt werden.

Download

Die Flash-Anwendung lässt sich hier herunterladen (rechte Maustaste -> Ziel speichern unter) …

Kostenloses Tool um Daten aus der SAP Transaktion SE16 per BULK INSERT in den Microsoft SQL Server importieren

Für schnelle Instant-Reportings, die praktisch auf „Knopfdruck“ benötigt werden, besteht in großen Unternehmen durch Restriktionen der IT oft nicht die Möglichkeit über SAP Standardschnittstellen auf Funktionsbausteine oder BAPIs zuzugreifen. Benötigt man die Versorgung von SAP Stammdaten einer Nicht-SAP-Lösung, welche mit vorrübergehenden Inkonsistenzen betrieben werden kann, lassen sich Stammdaten über die Transaktion SE16 besorgen. Diese können anschließend in den Microsoft SQL Server übertragen werden.

Die Vorteile von replizierten Daten liegen auf der Hand:

  • Keine Belastung des SAP Systems. Der SQL Server übernimmt die Anfragelast.
  • Höhere Performance (vorhersehbare Leistungseinbrüche führen nicht zum Wegbrechen der Datenquelle, deshalb…)
  • Höhere Verfügbarkeit der Daten
  • Unsichere Daten (z.B. Personalinformationen) können von Stammdaten getrennt werden
  • Ein fachkundiger Anwender kann entscheiden ob bestimmte Daten, die z.B. für Kanbanzwecke/Lieferantenreportings (VMI)/… benötigt werden, im Internet verfügbar sein dürfen. Diese Daten könnten auf einen einfachen MS SQL Server in der DMZ repliziert werden.
  • Die Daten können über eine Web-Anwendung und eine beliebige Web-Technologie eingelesen werden. Ein Web-Entwickler hat die volle Kontrolle auf relationaler Ebene und kann genau bestimmen, was  mit den Daten geschieht (keine Seiteneffekte durch unbekannte Logik in den SAP-Funktionsbausteinen).

Herunterladen von SAP Stammdaten aus der Transaktion SE16

Als Anmeldesprache bitte Sicherheitshalber „DE“ benutzen

Schritt 1: Tabelle wählen
Schritt 1: Tabelle wählen
Zweiter Bildschirm SE16
Zweites Bild: Tabellen anzeigen mit SE16 (hier bitte die maximale Trefferzahl auf 9999999 erhöhen)
Schritt 3: Download im Kontextmenü
Schritt 3: Download im Kontextmenü
Schritt 4: Unkovertiert auswählen und Dateiname angeben
Schritt 4: Unkovertiert auswählen und Dateiname angeben

Hierfür wird die Transaktion SE16 zunächst aufgerufen (Berechtigungen müssen vorhanden sein) und die entsprechende Stammdatentabelle selektiert.

Interessante Tabellen für den Materialstamm sind:

  • MAKT (Materialtexte)
  • MARA
  • MARC
  • MARD
  • MPOP
  • ….

Nachdem die Liste angezeigt wird, öffnet man mit einem Rechtsklick auf der Tabelle das Kontext-Menü und wählt die Option „Download“.

Für einen schnellen Download wählen wir die Option „unkonvertiert“. Die Option „Tabellenkalkulation“ ist aufgrund älterer Office-Versionen nur für eine Datensatzmenge von 65000 Einträgen interessant.

Als Download-Ort nehmen wir C:\Temp\mattexte.txt . Öffnet man die Heruntergeladenen Daten erhält man ein scheinbar unmögliches Format der Form:

Tabelle:        MAKT
Angezeigte Felder:  5 von  5  Feststehende Führungsspalten:  3  Listbreite 0250
----------------------------------------------------------------------------------------------------------------------
| |MANDT|MATNR               |SPRAS|MAKTX                                   |MAKTG                                   |
----------------------------------------------------------------------------------------------------------------------
| |100  |00022837            |E    |Stoßdämpfer      3.8.01758              |Stossdaempfer    3.8.01758              |
| |100  |0-275-W-5-0-NAG     |E    |Wagenständer      275CM                 |Wagenstaender 275CM                     |

Durchforstet man die runtergeladene Datei, stellt man fest das der Header-Anteil öfter vorkommt, je mehr Datensätze man runtergeladen hat. Bei einer Menge ab 1000000 Stück wiederholt sich der Header regelmäßig und scheinbar willkürlich, so dass es schwer erscheint ein Import-Tool dafür zu implementieren.

Doch dieses Format lässt sich ohne Probleme mit dem vorgestelltem .NET-Programm in einer hohen Geschwindigkeit (1.000.000 Datensätze in 1 Minute)  in den Microsoft SQL Server importieren. Hierbei wird das „BULK INSERT“-Verfahren verwendet. Dabei wird nicht 1.000.000 Mal ein INSERT-Statement ausgeführt, sondern die Datei binär zum Server übertragen.

Hochladen der SAP-Stammdaten in den MS SQL Server

Schritt 1: Unkovertierte Datei aus SE16 wählen^
Schritt 1: Unkovertierte Datei aus SE16 wählen
Schritt 2: Datenbankverbindung einrichten, testen und Zieltabellenname wählen (Create Statement wird automatisch anhand des Headers in der Textdatei generiert)
Schritt 2: Datenbankverbindung einrichten, testen und Zieltabellenname wählen (Create Statement wird automatisch anhand des Headers in der Textdatei generiert)
Schritt 3: Weiter klicken für hochladen
Schritt 3: Weiter klicken für hochladen

DOWNLOAD DES KOSTENLOSES IMPORTERS VON SE16 ZU MS SQL SERVER