berechnete Spalten können nicht in Systembeziehungen verwendet werden

Hallo
Ok, obwohl das "neuartige Diagramm" ganz vernünftige Ergebnisse liefert.

Was mir jetzt noch aufgefallen ist, dass der Code
Code:
Saison = "Saison" & Str(jjjj - 1) & "/" & Str(jjjj)
liefert zB: Saison 2012/ 2013 (Leerzeichen vor der 2. Jahreszahl).
bzw.
Code:
Saison = "Saison" & Str(jjjj - 1) & " /" & Str(jjjj)
liefert zB: Saison 2012 / 2013.
1. Leerzeichennach 2012 ist klar, aber woher kommt diese 2. Leerzeichen zwischen / und 2023 ?

Grüße
Markus
 
Werbung:
Hallo Andreas!
Vielen, vielen Dank für deine Hilfe.
Jetzt schauen meine DBen schon ganz gut aus und auch betreffend VBA habe ich jetzt schon ein paar Dinge zum Laufen gebracht.
Ich habe jetzt ein neues Thema "Anzeige Bearbeitungsstatus während VBA-Code-Ausführung" angesprochen (passt ja nicht mehr zu diesem Thema.
Grüße
Markus
 
Hallo Andreas!
Mit dem untenstehenden Code (siehe ganz unten) habe ich es ja Dank deiner Hilfe geschafft für alle Datensätze einer Abfrage Jahreszeiten und Saisonen zu berechnen und in alle Datensätze hineinzuschreiben. Dabei ist es notwendig die Datenbank bzw. Abfrage anzusprechen (Set rcsSport = db.OpenRecordset("A_Sport_alles", dbOpenDynaset), zu den Datensätzen zu navigieren und dann die Datenbank/Abfarge zu schliessen ( rcsSport.Close, Set rcsSport = Nothing)

Wo ich jetzt noch hänge ist. wie ich bei Neueingabe eines Datensatzes für diesen neuen Datensatz das Ergebnis der Berechnung in die Felder Saisonen bzw. Jahreszeit dieses Datensatzes schreiben kann.

Die Anlage eines neuen Datensatzes und Befüllen der Felder mittels Formular ist ja recht einfach
Mit dem Code
Code:
Private Sub Befehl17_Click()
 DoCmd.GoToRecord , , acNewRec
End Sub
wird im Formular ein leerer Datensatz generiert und nach Drücken der Pfeiltaste im Formular ist der neuen Datensatz auch schon angelegt.

Wie ich jetzt aber in diesen Code die Berechnung der Saisonen bzw. Jahreszeiten einbaue ist mir noch schleierhaft.

Kannst du mir da einen Tipp geben?
  • Muss ich da einen zusätzlichen Button für den Start einer eigenen Prozedur (Datenbank/Tabelle Öffnen, Berechnung, Daten in die Felder schreiben, DB schließen) oder geht das auch anderes?
  • oder Start einer Prozedur automatisch sobald das Datum eingegeben wurde?


Code:
Option Compare Database
Option Explicit

Private Sub Saison_JZ_neu_alle_Click()
'Sub Jahreszeiten_Saisonen_berechnen()
'***** Jahreszeiten und Saisonen berechnen und in neues Feld schreiben (dzt. in Feld bemerkung)
'***** Variablen deklarieren
    Dim Datumsstring As String
    Dim Suchdat As String
    'Dim Jahreszeit As String
    Dim Ergebnis_Jahreszeit As String
    'Dim Saison As String
    Dim Ergebnis_Saison As String
    'Dimensionierung Zähler
    Dim i As Long
    i = 1
'***** Verbindung zur DB
    Dim db As Database
    Set db = CurrentDb
'***** Recordset deklarieren
    Dim rcsSport As Recordset
'***** Recordset als Dynaset definieren
    Set rcsSport = db.OpenRecordset("A_Sport_alles", dbOpenDynaset)
    rcsSport.MoveLast 'finde letzten Datensatz
'***** Loop
    Do Until rcsSport.BOF 'Schleife bis zum Ende des Recordset
        Datumsstring = Format(CStr(Day(rcsSport.Fields("Datum"))) _
            + "." + CStr(Month(rcsSport.Fields("Datum"))) _
            + "." + CStr(Year(rcsSport.Fields("Datum"))), "dd.mm.yyyy") 'Übergabe an Variable und Format tt.mm.yyyy
        'Debug.Print "Datumsstring: " & Datumsstring  'Kontrolle Variable Datumsstring
        Let Suchdat = Datumsstring
        'Debug.Print "Suchdat: " & Suchdat
        rcsSport.Edit 'Änderung vornehmen
'***** Function Jahreszeit aufrufen
        Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
        'Debug.Print Ergebnis_Jahreszeit
        rcsSport.Fields("Jahreszeit") = Ergebnis_Jahreszeit 'Datenfelder ergänzen
'***** Function Saison aufrufen
        Let Ergebnis_Saison = Saison(Suchdat)
        Debug.Print Ergebnis_Saison
        Debug.Print rcsSport.Fields("Datum")
        
        rcsSport.Fields("Saison") = Ergebnis_Saison 'Datenfelder ergänzen
'*****
    rcsSport.Update 'Aktualisierung durchführen
    rcsSport.MovePrevious 'vorheriger Datensatz
    i = i + 1
  
      Me.Zaehler = i
      DoEvents
    
    Loop
    rcsSport.Close
    Set rcsSport = Nothing
End Sub
'***** Function zur Umrechnung des Datums in einen Jahreszeit
Public Function Jahreszeit(Suchdat As String) As String 'Eingabe gültiges Datum als String "tt.mm.jjjj"
 Dim mmtt As Integer
 Dim jjjj As Integer
 mmtt = Val(Mid(Suchdat, 4, 2)) * 100 + Val(Mid(Suchdat, 1, 2))
 jjjj = Val(Mid(Suchdat, 7, 4))
 'Debug.Print "Monat: " & Val(Mid(Suchdat, 4, 2))
 'Debug.Print "Tag: " & Val(Mid(Suchdat, 1, 2))
 'Debug.Print "Jahr: " & Val(Mid(Suchdat, 7, 4))
 'Debug.Print "mmtt: " & mmtt
 'Debug.Print "jjjj: " & jjjj
 
 Select Case mmtt
        Case 301 To 531
             Jahreszeit = "Frü " & Right(Str(jjjj), 2)
        Case 601 To 831
             Jahreszeit = "Som " & Right(Str(jjjj), 2)
        Case 901 To 1130
             Jahreszeit = "Her " & Right(Str(jjjj), 2)
        Case 1201 To 1231
             Jahreszeit = "Win " & Right(Str(jjjj), 2) & "/" & Right(Str(jjjj + 1), 2)
        Case 101 To 229
             Jahreszeit = "Win " & Right(Str(jjjj - 1), 2) & "/" & Right(Str(jjjj), 2)
        Case Else
             Jahreszeit = "Fehler in der Jahreszeitermittlung"
 End Select
End Function

'***** Function zur Umrechnung des Datums in eine Saison
Public Function Saison(Suchdat As String) 'Eingabe gültiges Datum als String "tt.mm.jjjj"
   Dim mmtt As Integer
   Dim jjjj As Integer
   mmtt = Val(Mid(Suchdat, 4, 2)) * 100 + Val(Mid(Suchdat, 1, 2))
   jjjj = Val(Mid(Suchdat, 7, 4))
   Select Case mmtt
          Case 701 To 1231
               Saison = "S " & Right(Str(jjjj), 2) & "/" & Right(Str(jjjj + 1), 2)
          Case 101 To 630
               Saison = "S " & Right(Str(jjjj - 1), 2) & "/" & Right(Str(jjjj), 2)
    
          Case Else
             Saison = "Fehler in der Saisonermittling"
   End Select
End Function
 
Moin,
da Du ja immer noch nicht davon abzubringen bist berechnete Felder in Tabellen zu schreiben....;)

Nehme die Tabellenfelder mit in dein Formular. Die sind dann natürlich bei der Neuanlage leer.
Dann erstellst Du unter dem Formularereignis "beim Anzeigen" (Current) eine Prozedur, die die Felder im Falle der Neuanlage (If Me.NewRecord) berechnet und füllt.

Um nur plausible Daten abzuspeichern würde ich noch im Formulareieignis "vor Aktualisierung" (before_Update) eine Prüfung der Felder durchführen.

Access aktualisiert den Datensatz automatisch, wenn das Formular verlassen oder der Datensatzge wechselt wird. Es ist also kein Extrabutton nötig. Wenn Du eine Aktualisierung möchtest ohne das Formular zu verlassen oder den Datensatz zu wechseln gibt es Requery, Refresh, Repaint, Recalc, jenachdem zu welcher Situation.
 
Hallo Andreas
Danke

Ich habe jetzt nach einigem Testen folgende Frage:
Ich habe ja bereits im Formular "Neuberechnung_Saison_Jahreszeit_alle" die Prozedur "Private Sub Saison_JZ_neu_alle_Click()" und die beiden Functions "Public Function Saison(Suchdat ......" und "Public Function Jahreszeit(Suchdat ......" hinterlegt.

Wenn ich nun in meinem Eingabeformular für neue Datensätze wie du vorhin anführst eine Ereignisprozedur hinterlege und von dort die "Public Function Jahreszeit" und "Public Function Saison" aufrufen will, dann bringt er eine Fehlermeldung dass er die Function nicht findet. Wenn ich diese Functions bei diesem Formular nochmal hinterlege kommt die Fehlermeldung dass diese Functions bereits existieren. Wenn ich die Functions einfach umbenenne (zB Public Function Jahreszeit2(Suchdat ......") dann keine Fehlermeldung.

Ist eine Function nur innerhalb eines Formulars gültig?
Warum bringt er aber dann einen Fehlermeldung wenn ich eine Function mit gelichem namen in verdschiednen Formlaren habe.

Noch einen Frage:
Eigentlich könnte ich ja auch beim Anlegen eines neuen Datensatzes gleich nach Eingabe des Datum sofort die Jahreszeit bzw. Saison berechnen
Also beim Feld "Datum" entweder beim Menüeintrag "Bei Änderung" die Prozedur "Private Sub Text1_Change()" oder beim Menüeintrag "Nach Aktualiserung" die Prozedur "Private Sub Text1_AfterUpdate()" untenstehenden Code hinterlegen:

Dies funktioniert aber nur wenn ich die Function nicht gleich benenne wie die Function im anderen Formular, also Ajhreszeit2 bzw. Saison2
Es wird zwar alles richtig berechnet aber die Felder Me.Jahreszeit bzw- Me.Saison werden nicht befüllt.

Code:
Option Compare Database
Option Explicit

Private Sub Befehl0_Click()
DoCmd.GoToRecord , , acNewRec
End Sub


Private Sub Text1_AfterUpdate()
'***** Variablen deklarieren
    Dim Datumsstring As String
    Dim Suchdat As String
    Dim Jahreszeit As String
    Dim Ergebnis_Jahreszeit As String
    Dim Saison As String
    Dim Ergebnis_Saison As String
Datumsstring = Format(CStr(Day(Me.Datum)) _
            + "." + CStr(Month(Me.Datum)) _
            + "." + CStr(Year(Me.Datum)), _
            "dd.mm.yyyy") _
            'Übergabe an Variable und Format tt.mm.yyyy
           Debug.Print Datumsstring
  Let Suchdat = Datumsstring
'***** Function Jahreszeit aufrufen
    Let Ergebnis_Jahreszeit = Jahreszeit2(Suchdat)
    Debug.Print Ergebnis_Jahreszeit
    Me.Jahreszeit = Ergebnis_Jahreszeit

'***** Function Saison aufrufen
    Let Ergebnis_Saison = Saison2(Suchdat)
    Debug.Print Ergebnis_Saison
    Me.Saison = Ergebnis_Saison
  
 MsgBox ("Datensatz neu angelegt")

End Sub


'***** Function zur Umrechnung des Datums in einen Jahreszeit
Public Function Jahreszeit2(Suchdat As String) As String 'Eingabe gültiges Datum als String "tt.mm.jjjj"
 Dim mmtt As Integer
 Dim jjjj As Integer
 mmtt = Val(Mid(Suchdat, 4, 2)) * 100 + Val(Mid(Suchdat, 1, 2))
 jjjj = Val(Mid(Suchdat, 7, 4))
 'Debug.Print "Monat: " & Val(Mid(Suchdat, 4, 2))
 'Debug.Print "Tag: " & Val(Mid(Suchdat, 1, 2))
 'Debug.Print "Jahr: " & Val(Mid(Suchdat, 7, 4))
 'Debug.Print "mmtt: " & mmtt
 'Debug.Print "jjjj: " & jjjj
 
 Select Case mmtt
        Case 301 To 531
             Jahreszeit = "Frü " & Right(Str(jjjj), 2)
        Case 601 To 831
             Jahreszeit = "Som " & Right(Str(jjjj), 2)
        Case 901 To 1130
             Jahreszeit = "Her " & Right(Str(jjjj), 2)
        Case 1201 To 1231
             Jahreszeit = "Win " & Right(Str(jjjj), 2) & "/" & Right(Str(jjjj + 1), 2)
        Case 101 To 229
             Jahreszeit = "Win " & Right(Str(jjjj - 1), 2) & "/" & Right(Str(jjjj), 2)
        Case Else
             Jahreszeit = "Fehler in der Jahreszeitermittlung"
 End Select
Debug.Print Jahreszeit
End Function

'***** Function zur Umrechnung des Datums in eine Saison
Public Function Saison2(Suchdat As String) 'Eingabe gültiges Datum als String "tt.mm.jjjj"
   Dim mmtt As Integer
   Dim jjjj As Integer
   mmtt = Val(Mid(Suchdat, 4, 2)) * 100 + Val(Mid(Suchdat, 1, 2))
   jjjj = Val(Mid(Suchdat, 7, 4))

   
   Select Case mmtt
          Case 701 To 1231
               Saison = "S " & Right(Str(jjjj), 4) & "/" & Right(Str(jjjj + 1), 2)
          Case 101 To 630
               Saison = "S " & Right(Str(jjjj - 1), 4) & "/" & Right(Str(jjjj), 2)
          Case Else
             Saison = "Fehler in der Saisonermittling"
   End Select
   Debug.Print Saison
End Function
 
Du solltest "Public Function" auch Public hinterlegen, also in einem eigenen allgemeinen Modul. Formularmodule sind Klassenmodule deren Prozeduren nur innerhalb erreichbar sind. Beschäftige dich Mal mit Lebensdauer, Gültigkeit von Variablen und Prozeduren.
 
Hi
Ich habe mich jetzt mit dem Thema der Lebensdauer, Gültigkeit beschäftigt, bekomme aber doch eine Fehlermeldung.

Ich habe jetzt die Funktionen zur Berechnung Jahreszeit und Saison in ein eigenes Modul gepackt:
Im Folgendes dieses Module, ..... bedeutet hier steht natürlich noch mehr Code.

Code:
'***** Function zur Umrechnung des Datums in einen Jahreszeit
Public Function Jahreszeit(Suchdat As String) As String 'Eingabe gültiges Datum als String "tt.mm.jjjj"
 ....... 
 Select Case mmtt
        Case 301 To 531
             Jahreszeit = "Frü " & Right(Str(jjjj), 2)
 ......
 End Select
End Function

'***** Function zur Umrechnung des Datums in eine Saison
Public Function Saison(Suchdat As String) 'Eingabe gültiges Datum als String "tt.mm.jjjj"
  ........
   Select Case mmtt
          Case 701 To 1231
               Saison = "S " & Right(Str(jjjj), 4) & "/" & Right(Str(jjjj + 1), 2)
   ......
   End Select
End Function

Zur (Neu)-Berechnung für alle Datensätze nutze ich folgende Prozedur in einem anderem Module (hinterlegt in einem eigenen Formular

Code:
Option Compare Database
Option Explicit

Private Sub Saison_JZ_neu_alle_T_Auto_Click()
'Sub Jahreszeiten_Saisonen_berechnen für Tabelle T_Auto
'***** Variablen deklarieren
    .......
    'Dim Jahreszeit As String
    Dim Ergebnis_Jahreszeit As String
    'Dim Saison As String
    Dim Ergebnis_Saison As String
    .....................
'***** Function Jahreszeit aufrufen
        Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
        rcsAuto.Fields("Jahreszeit") = Ergebnis_Jahreszeit 'Datenfelder ergänzen
'***** Function Saison aufrufen
        Let Ergebnis_Saison = Saison(Suchdat)
        Debug.Print rcsAuto.Fields("Datum")
...........................
End Sub

Private Sub Saison_JZ_neu_alle_T_Zähler_Click()
'Sub Jahreszeiten_Saisonen_berechnen für Tabelle T_Zähler
.........................
End Sub

Das funktioniert auch perfekt.

Wenn ich aber die Berechnung Jahreszeit bzw Saison bei einem einzelnen neu einzugebenden Datensatz mache, habe ich folgendes Problem:
Ich starte mit einem Button die Ereignisprozedur zum Anlegen eines neuen Datensatzes

Code:
Private Sub Befehl0_Click()
DoCmd.GoToRecord , , acNewRec
End Sub

Das funktioniert noch gut.

Nun will ich sobald ich das Datumsfeld befüllt habe, dass dann gleich die Datenfelder Jahreszeit und Saison berechnet und befüllt werden. Dafür habe ich folgenden Code bei "Public Sub Text1_Change()" (Das Datumsfeld heisst Text1) geschrieben (hier den gesamten Code für diese Eingabeformular):

Code:
Option Compare Database
Option Explicit

Private Sub Befehl0_Click()
DoCmd.GoToRecord , , acNewRec
End Sub

Public Sub Text1_Change()
If Me.NewRecord Then
'***** Variablen deklarieren
    Dim Datumsstring As String
    Dim Suchdat As String
    Dim Jahreszeit As String
    Dim Ergebnis_Jahreszeit As String
    Dim Saison As String
    Dim Ergebnis_Saison As String
Datumsstring = Format(CStr(Day(Me.Datum)) _
            + "." + CStr(Month(Me.Datum)) _
            + "." + CStr(Year(Me.Datum)), _
            "dd.mm.yyyy")
            'Übergabe an Variable und Format tt.mm.yyyy
 Debug.Print Datumsstring
 Let Suchdat = Datumsstring

'***** Function Jahreszeit aufrufen
  Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
  Debug.Print Ergebnis_Jahreszeit
  Me.Jahreszeit = Ergebnis_Jahreszeit

'***** Function Saison aufrufen
  Let Ergebnis_Saison = Saison(Suchdat)
  Debug.Print Ergebnis_Saison
  Me.Saison = Ergebnis_Saison
 
End Sub

Nach Eingabe des Datums bekomme ich dann aber die Fehlermeldung:
Fehler beim Kompilieren: Erwartet: Datenfeld
Nach Bestätigen dieser Fehlermeldung wird die Prozedur "Public Sub Text1_Change()" gelb hinterlegt und in der Codezeile "Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)" wird rechts Jahreszeit blau hinterlegt.

Aus dieser Prozedur müsste er ja die Functions in dem eigenen Modul aufrufen, so wie es ja auch bei der Prozedur erfolgt, bei der ich das für alle Datensätze berechnen

Wenn ich testhalber die Functions Jahreszeit und Saison auch in dieses Formularmodul hineinkopiere bekomme ich richtigerweise die Fehlermeldung dass das Formularmodul schon vorhanden ist
 
So einen Fehler hatten wir schon mal: Wo ist denn der Code blau hinterlegt, wenn die Fehlermeldung kommt?

p.s. Das Befehlswort "Let" bei einer Zuweisung kannst Du getrost immer weglassen.
 
Hi

Sieht so aus

"Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)"

Was ich blau/fett gekennzeichnet habe wird mit blauer Farbe hinterlegt

PS: Fehlermeldung kommt auch wenn ich Let weglasse

Grüße
Markus
 

Anhänge

  • Fehler.webp
    Fehler.webp
    9,2 KB · Aufrufe: 2
Du hast Jahreszeit und Saison als Variablen in der Prozedur dimensioniert. Das sind aber die Funktionsnamen. Eine Dim-Anweisung hat jedoch Vorrang vor einem Funktionsnamen. Die beiden Dims müssen also raus.
 
HI
Irgendwie scheint Access da etwas eigenwillig zu sein

Ich habe jetzt den Code, dass nach Eingabe des Datums Jahreszeit und Saison berechnet wird angepasst
Code:
Private Sub Text1_AfterUpdate()
'***** Variablen deklarieren
    Dim Datumsstring As String
    Dim Suchdat As String
    Dim Ergebnis_Jahreszeit As String
    Dim Ergebnis_Saison As String
    Debug.Print Me.Datum
Datumsstring = Format(CStr(Day(Me.Datum)) _
            + "." + CStr(Month(Me.Datum)) _
            + "." + CStr(Year(Me.Datum)), "dd.mm.yyyy")
            'Übergabe an Variable und Format tt.mm.yyyy
 Debug.Print "Datumsstring " & Datumsstring
 Let Suchdat = Datumsstring
 Debug.Print "Suchdat " & Suchdat
'***** Function Jahreszeit aufrufen
  Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
  Debug.Print Ergebnis_Jahreszeit
  Me.Jahreszeit = Ergebnis_Jahreszeit

'***** Function Saison aufrufen
  Let Ergebnis_Saison = Saison(Suchdat)
  Debug.Print Ergebnis_Saison
  Me.Saison = Ergebnis_Saison
 MsgBox ("Datensatz neu angelegt")
End Sub

Das sind eigentlich genau die gleichen Codeteile
Code:
Datumsstring = Format(CStr(Day(Me.Datum)) _
            + "." + CStr(Month(Me.Datum)) _
            + "." + CStr(Year(Me.Datum)), "dd.mm.yyyy")
            'Übergabe an Variable und Format tt.mm.yyyy
 Let Suchdat = Datumsstring
Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)

die ich bei Berechnung für alle Datensätze anwende (fett die jeweils relevanten Codezeilen)

Code:
Private Sub Saison_JZ_neu_alle_T_Auto_Click()
'Sub Jahreszeiten_Saisonen_berechnen()
    Dim Datumsstring As String
    Dim Suchdat As String
    Dim Ergebnis_Jahreszeit As String
    Dim Ergebnis_Saison As String
    'Dimensionierung Zähler
    Dim i As Long
    i = 1
'***** Verbindung zur DB
    Dim db As Database
    Set db = CurrentDb
'***** Recordset deklarieren
    Dim rcsAuto As Recordset
'***** Recordset als Dynaset definieren
    Set rcsAuto = db.OpenRecordset("T_Auto", dbOpenDynaset)
    rcsAuto.MoveLast 'finde letzten Datensatz
'***** Loop
    Do Until rcsAuto.BOF 'Schleife bis zum Ende des Recordset
        Datumsstring = Format(CStr(Day(rcsAuto.Fields("Datum"))) _
        + "." + CStr(Month(rcsAuto.Fields("Datum"))) _
        + "." + CStr(Year(rcsAuto.Fields("Datum"))), "dd.mm.yyyy")
        'Übergabe an Variable und Format tt.mm.yyyy
        'Debug.Print "Datumsstring: " & Datumsstring  'Kontrolle Variable Datumsstring
        Let Suchdat = Datumsstring
        'Debug.Print "Suchdat: " & Suchdat
        rcsAuto.Edit 'Änderung vornehmen
'***** Function Jahreszeit aufrufen
        Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
        Debug.Print Ergebnis_Jahreszeit
        rcsAuto.Fields("Jahreszeit") = Ergebnis_Jahreszeit 'Datenfelder ergänzen
'***** Function Saison aufrufen
        Let Ergebnis_Saison = Saison(Suchdat)
        Debug.Print Ergebnis_Saison
        Debug.Print rcsAuto.Fields("Datum")
       
        rcsAuto.Fields("Saison") = Ergebnis_Saison 'Datenfelder ergänzen
'*****
    rcsAuto.Update 'Aktualisierung durchführen
    rcsAuto.MovePrevious 'vorheriger Datensatz
    i = i + 1
      Me.Zaehler2 = i
      DoEvents
    Loop
    rcsAuto.Close
    Set rcsAuto = Nothing
End Sub

Debug.Print "Suchdat: " & Suchdat zeigt auch das richtige Format an: zB 01.03.2020

Trotzdem bekomme ich nach Eingabe des Datum und Klicken auf ein anderes Feld folgende Fehlermeldung
"Laufzeitfehler 13: Typen unverträglich"

und die Codezeile "Let Ergebnis_Jahreszeit = Jahreszeit(Suchdat)" wird gelb hinterlegt,

Das habe ich schon probiert:
  • nur Ergebnis_Jahreszeit = Jahreszeit(Suchdat)
  • da der Inhalt des Feldes Me.Datum bereits das Format tt.mm.jjjj Jahr hat, habe ich "Ergebnis_Jahreszeit = Jahreszeit(Me.Datum)" probiert
Aber immer dieselbe Fehlermeldung.

Den Tipp betreffend Access FAQ 7.11 habe ich auch schon probiert aber da bekomme ich die Fehlermeldung; Fehler beim Laden der DLL - kann diese in diesem fall überhaupt eine Rolle spielen?

Grüße Markus
 
Schwer nachzuvollziehen. Ist die Funktion Jahreszeit richtig als String deklariert? Wenn man den Code nicht debuggen kann, ist es schwer.
Schau dir mal die Funktion VarType in der Microsoft-HIlfe an, damit kannst Du den Typ einer Variablen überprüfen. Beispiel:
Code:
Debug.Print VarType(Ergebnis_Jahreszeit)
Die Funktion gibt eine Zahl aus , die den Variablentyp anzeigt. z.B. 8 für einen String oder 0 wenn die Variable garnicht initialsiert ist.
 
Werbung:
Hallo
Das habe ich nun ausprobiert, und das ist nicht die Fehlerquelle, denn Vartype ergibt 8 und damit übergebe ich einen String an die Functions

Ich habe jetzt nochmals alles kontrolliert, finde aber den Fehler nicht.
Beiliegend die Datenbank, vielleicht kannst du das mal ausprobieren (nicht das an der Access-Installation liegt)

In der Datenbank findest du 2 Tabellen
  • T_Auto: das sind die Aufladungen des Autoakkus
  • T_Zähler: das sind die Zählermesswerte
Mehrere Abfragen zB
  • A_Auto_....; wertet die Autoladungen aus
  • A_Energie_....: wertet die Energieverbräuche aus (jeweils basierend auf der Logik: FROM T_Zähler AS A LEFT JOIN T_Zähler AS B ON A.ID = B.ID+1)
Formular F_Neuberechnung_Saison_JZ_alle
Hier berechne ich Jahreszeit und Saison für alle Datensätze in T_Auto und T_Zähler - das funktioniert!!!

Formular F_EingabeneueLadungAuto
  • Hier lege ich einerseits neue Datensätze an (mit DoCmd.GoToRecord , , acNewRec) - das funktioniert !!
  • Beim Feld Datum habe ich die Ereignisprozedur Private Sub Datum_AfterUpdate() hinterlegt und hier kommt es nach Erstellen eines neuen Datensatzes und nach Eingabe des Datum und Anklicken eines anderen Feldes die Fehlermeldung "Laufzeitfehler 13: Typen unverträglich"
Ich habe mehere Debug.Print Vartype(....) eingebaut, Ergebnis:
Vartype Me.Datum: 7
Vartype Datumsstring: 8
Datumsstring 24.04.2025
Suchdat 24.04.2025
Vartype Suchdat: 8 --> das sollte somit eigentlich passen

Grüße
Markus
 

Anhänge

Zurück
Oben