Help splitting up a character address string

[Rick Lipkin]

To All

I seem to have lost my ability to substring an Address field into seperate cStreet, cCity, cState and cZip variables ...

here is a address field I want to break out into the above fields

cAddress := "258 Shoreline Drive, Columbia, SC 29212"

Please help me with the code to breakout the

CStreet = 258 Shoreline Drive"
CCity = "Columbia"
CState = "SC"
CZip = "29212"

if I recall you can use the At() function to find the comma "," and substring the cAddress variable into the various attributes ... Any code help would be greatly appreciated!

Thanks
Rick Lipkin

[Antonio Linares]

Dear Rick,

Code: Select all  Expand view  RUN

#include "FiveWin.ch"

function Main()

   local cAddress := "258 Shoreline Drive, Columbia, SC 29212"
   
   XBrowse( hb_ATokens( cAddress, "," ) )

return nil

[Rick Lipkin]

Antonio .. All

I had to dig out my old dBase\Harbour help file for the correct use of AT() and RAT() but I finially wrote a function I can use to take a full address field and break it into Street, City,State and Zip .. here is the code :

Code: Select all  Expand view  RUN

// test.prg

#INCLUDE "FIVEWIN.CH"

Function Main()

Local cAddress,cStreet,cCity,cState,cZip,nAt,nRat,nLen,nDiff,nRat1,nDiff1

cAddress := "258 Shoreline Drive, Columbia, SC 29212"

nLen := len( cAddress )
msginfo( nLen )             //39

nAt := at(",", cAddress )
msginfo( nAT )              // 20


cStreet := substr(cAddress,1,nAt-1)

msginfo( cStreet )           // 258 Shoreline Drive

nRAt := rat(",", cAddress )  // 30
msginfo( nRAt )

nDiff := nRat - nAt
msginfo( nDiff )             // 10


cCity := substr(cAddress,(nAt+1),(nDiff-1))
msginfo( cCity )             // Columbia

cState := substr( cAddress, nRat+2,2)
msginfo( cState )           // SC

nRat1 := rat(" ",cAddress)
msginfo( nRat1 )             // 34

cZip := substr(cAddress,nRat1+1,5)
msginfo( cZip )               // 29212

Return(.t.)
// end

 

Thanks ... Rick Lipkin

[Otto]

Rick, why searching your notes? Ask ChatGPT:

Additional Details: '
harbour'

:'

Help splitting up a character address string

Postby Rick Lipkin » Tue Nov 14, 2023 9:29 pm
To All

I seem to have lost my ability to substring an Address field into seperate cStreet, cCity, cState and cZip variables ...

here is a address field I want to break out into the above fields

cAddress := "258 Shoreline Drive, Columbia, SC 29212"

Please help me with the code to breakout the

CStreet = 258 Shoreline Drive"
CCity = "Columbia"
CState = "SC"
CZip = "29212"

if I recall you can use the At() function to find the comma "," and substring the cAddress variable into the various attributes ... Any code help would be greatly appreciated!

Thanks'

ChatGPT
To split the address string into separate variables for street, city, state, and zip code, you can indeed use the At() function or similar string manipulation functions. The approach depends on the programming language you're using. I'll provide an example in a commonly used language, Python, which should give you a good idea of how to implement it in your specific language.

In Python, you can use the split() method to divide the string at commas and spaces. Here's how you could do it:

python
Copy code
cAddress = "258 Shoreline Drive, Columbia, SC 29212"

# Split the address into components
components = cAddress.split(", ")

# Assign each component to its respective variable
cStreet = components[0]
cCity = components[1]
cStateZip = components[2].split(" ")
cState = cStateZip[0]
cZip = cStateZip[1]

# Print the results
print("CStreet =", cStreet)
print("CCity =", cCity)
print("CState =", cState)
print("CZip =", cZip)
This code will output:

makefile
Copy code
CStreet = 258 Shoreline Drive
CCity = Columbia
CState = SC
CZip = 29212
You will need to adapt this logic to the specific syntax and functions of the programming language you are using. If you're using a language that supports regular expressions, that could be an even more robust solution. Let me know if you need help in a specific programming language!

User
I need harbour code
ChatGPT
To split the address string in Harbour, a language similar to Clipper, you can use the SubStr() and At() functions to locate and extract the specific parts of the address. Harbour's string handling functions are quite powerful for these types of operations.

Here's how you can do it in Harbour:

harbour
Copy code
FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}
ENDFUNCTION

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]
This function first finds the positions of the commas in the address, then uses SubStr() to extract the different parts based on those positions. The result is stored in an array, but you can modify this to suit your needs, such as assigning them to variables or processing them further.

User
is ENDFUNCTION really a harbour syntax
ChatGPT
You're right, my mistake. In Harbour, the correct syntax to end a function is RETURN for the function's return value and FUNCTION to declare the end of the function, not ENDFUNCTION as I previously stated. Here's the corrected code:

harbour
Copy code
FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}
END FUNCTION

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]
In this corrected version, the function is properly terminated with END FUNCTION. Thank you for pointing out the error!

User
I think end funtion is not working - never saw this on harbour
ChatGPT
You are correct, and I apologize for the confusion in my previous messages. In Harbour, to define the end of a function, you simply use RETURN at the point where you want the function to end and return a value. There is no specific keyword like END FUNCTION to denote the end of the function block as in some other languages.

The corrected Harbour code would look like this:

harbour
Copy code
FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}
ENDFUNCTION

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]
In this code, RETURN is used both to return the value at the end of the function and to indicate the end of the function block. Thank you for your patience, and I hope this solution works for you in Harbour.

[Otto]

I think it's important that we ask Harbour questions. ChatGPT learns! I am the only user of harbourino but I am already getting some good hits.

This approach, facilitated by Harbourino, makes your code more organized and easier to maintain. Each function or module can be kept in separate files, making the codebase cleaner and more modular.

Code: Select all  Expand view  RUN

#include "fivewin.ch"

function main

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]

return nil
//----------------------------------------------------------------------------//

$-> SplitAddress.prg

//----------------------------------------------------------------------------//




 

FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}

/browse
ChatGPT
Error analyzing
Harbourino appears to be a preprocessor tool used in conjunction with mod_harbour and Fivewin, which are both related to the Harbour programming language. Harbour is an open-source compiler for the xBase superset language often used to create database applications.

Use in mod_harbour: Harbourino seems to play a significant role in simplifying the source code for mod_harbour applications. According to a post by a user named Otto on the mod_harbour forum, Harbourino aids in making source code more readable and maintainable. This is achieved through its patcher and preprocessor capabilities, which allow for a more organized and streamlined coding process. In mod_harbour applications, the main program can be simplified to just a few lines using Harbourino, facilitating the construction of the application framework​​.

Application in Fivewin: Harbourino is not limited to mod_harbour; it's also used in Fivewin environments. Fivewin is a tool used to create graphical user interfaces for Harbour applications. In this context, Harbourino helps in breaking down complex functions into simpler, more manageable modules. This modular approach, as indicated in the FiveTech Software tech support forums, allows for easier management of different parts of an application, such as xBrowse. By patching individual .prg files back into one, Harbourino enhances the organization and manageability of the code​​​​.

Practical Example and Training: Another post on the FiveTech Software tech support forums mentions an offer to demonstrate how to create mod harbour programs using Harbourino in a Skype session. This implies that there might be training or instructional sessions available for learning how to effectively use Harbourino in developing web pages driven by DBF (database file) data using mod harbour. This highlights Harbourino's role in facilitating the development of dynamic web applications using Harbour​​.

These insights suggest that Harbourino serves as an invaluable tool for developers working with Harbour, particularly in web and GUI application development. It enhances code readability, maintainability, and modularity, which are crucial aspects of efficient software development.

User
gibt es infos zur syntax
ChatGPT
Detailed information about the syntax and usage of Harbourino, particularly within the context of mod_harbour and Fivewin, is somewhat scarce. The few references found in online forums suggest that Harbourino is a tool used to enhance code readability and manageability, particularly in web and GUI application development with Harbour.

In the context of mod_harbour, Harbourino is mentioned as a tool that makes source code more readable and maintainable. It seems to function as both a patcher and a preprocessor, helping to organize and streamline coding processes in mod_harbour applications​​.

In Fivewin environments, Harbourino assists in breaking down complex functions into simpler, more manageable modules. This modular approach is particularly beneficial for managing different parts of an application like xBrowse. Harbourino patches individual .prg files into one, enhancing code organization and manageability​​.

There's a mention of a Harbourino Manager, which suggests that all functions of Harbourino can be carried out from a single console. This might indicate a user-friendly interface for managing various aspects of Harbourino's functionality. However, specific details about its syntax or direct examples of its use are not readily available in these sources​​.

For comprehensive details on the syntax and usage of Harbourino, it would be best to directly contact the developers or contributors involved in its creation, or to refer to any official documentation that may exist for Harbourino, if available.

User
Harbourino.pdf
PDF
sag mir etwas zur syntax
ChatGPT
The document on Harbourino provides insight into its functionality as a preprocessor. Key points include:

Functionality: Harbourino is a preprocessor that simplifies the development, readability, and modification of code. It takes a text file written in a certain programming language syntax and outputs another text file in a different language's syntax.

Features: It offers file inclusion, substitution facilities, and conditional compilation.

Modularity: Harbourino enables splitting complex functions or classes into smaller, manageable files. For example, you can have a separate file for each method of a class, adhering to programming best practices like keeping functions to a single printed page.

Syntax Examples:

$-> is used to link include files and make simple textual substitutions.
Placeholders like |UNIQUEID| or | placeholder | are used.
Commands like $-> Filename 9999: placeholder=xxxxxxxx; allow for specific file operations.
Comments can be made in include files using |- and won't appear in the patched release file.
Preprocessor Inside Paragraphs: It allows preprocessing within paragraphs for cleaner code structure, as shown in an example with HTML and JavaScript code.

Path Management: Harbourino can manage paths in source code through placeholders and settings in an INI file.

Harbourino Manager: It is mentioned that all Harbourino functions can be managed from one console.

This document provides a good overview of Harbourino's capabilities, emphasizing its utility in making code more manageable and maintainable, especially for beginners or less experienced programmers.

User
kannst du mir ein beispiel geben, wie harbourino code aussehe könnte: '#include "fivewin.ch"

function main

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]

return nil
//----------------------------------------------------------------------------//


FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}

//----------------------------------------------------------------------------//

' hier ist der gesamte sourcecode.
ChatGPT
Using Harbourino, the given Harbour code can be refactored to demonstrate how Harbourino's preprocessor functionality might be applied. The main idea is to split complex functions or code segments into manageable modules. This example shows how to use include directives and placeholders to modularize the SplitAddress function:

harbour
Copy code
#include "fivewin.ch"

function main

// Example usage
LOCAL aAddressParts
aAddressParts := SplitAddress("258 Shoreline Drive, Columbia, SC 29212")

? "CStreet =", aAddressParts[1]
? "CCity =", aAddressParts[2]
? "CState =", aAddressParts[3]
? "CZip =", aAddressParts[4]

return nil
//----------------------------------------------------------------------------//

$-> SplitAddress.prg

//----------------------------------------------------------------------------//
In SplitAddress.prg, you would place the SplitAddress function:

harbour
Copy code
FUNCTION SplitAddress(cAddress)
LOCAL cStreet, cCity, cState, cZip
LOCAL nPos1, nPos2

// Find the position of the commas
nPos1 := At(",", cAddress)
nPos2 := At(",", cAddress, nPos1 + 1)

// Extract the street, city, state, and zip
cStreet := SubStr(cAddress, 1, nPos1 - 1)
cCity := SubStr(cAddress, nPos1 + 2, nPos2 - nPos1 - 2)
cState := SubStr(cAddress, nPos2 + 2, 2)
cZip := SubStr(cAddress, nPos2 + 5)

// Return as an array, or handle as needed
RETURN {cStreet, cCity, cState, cZip}
END
This approach, facilitated by Harbourino, makes your code more organized and easier to maintain. Each function or module can be kept in separate files, making the codebase cleaner and more modular.

[TimStone]

I think we are aging ... having to go back and look at previous code to remember "how we did it".
BTDT ...

[Rick Lipkin]

Otto

I am taking an Excel spreadsheet whos data is taken from a web form. I then have to take that Excel file and write a conversion program that starts at column 1 thru the end column ( whatever ) and take all those values and stuff them into a temp .dbf file. The SQL table has Street,City, State and Zip .. however the Address excel column has street,city,state and zip concatenated into one excel column .. so the trick is as I loop through the for\next loop ... that I run the conversion from the value "City,State ZIP" into it individual fields .. I don't think ChatGPT will help me much in this Excel to dbf conversion .

Thanks
Rick Lipkin

[Otto]

Rick, I think it has created exactly the program AT() that you posted.
Best regards,
Otto

[Otto]

Rick, I think the answer is not so bad.
Best regards,
Otto

Code: Select all  Expand view  RUN

It sounds like you have a two-part problem:

Extracting Data from Excel: You need to read data from an Excel spreadsheet. This data is structured with several columns, and notably, one of the columns combines multiple data fields (street, city, state, and zip) into a single string.

Creating a .DBF File with Separated Data Fields: You then need to convert this data into a .DBF file format, which will be used for an SQL database. The challenge is to split the concatenated address column into separate fields for street, city, state, and zip, and then populate these into the .DBF file.

To solve this, you'll need a program that can:

Read data from an Excel file.
Parse the concatenated address field into separate components.
Write these components, along with the other data from the Excel file, into a .DBF file.
Harbour, a programming language you mentioned, is well-suited for database operations but might not be the most straightforward tool for parsing Excel files and text manipulation. A more common approach would be to use Python with libraries like pandas for handling Excel files and dbfread or simpledbf for creating .DBF files.

Would you like a Python script example that demonstrates this process, or do you specifically need help with implementing this in Harbour?

User
show me please a harbour solution
ChatGPT
Creating a program in Harbour to process an Excel file, extract and manipulate data, and then export it to a .DBF file is quite specialized. Harbour, being a derivative of the xBase language, excels in database operations but isn't natively equipped to handle Excel files. Typically, you'd use a combination of Harbour and another tool or library that can read Excel files.

Here's a high-level overview of how you might approach this in Harbour:

Read the Excel File: Since Harbour doesn't natively support reading Excel files, you'd typically convert the Excel file to a CSV format first. You can do this manually in Excel or use a script in another language that can automate this task.

Process the CSV File in Harbour:

Load the CSV file into a program.
Loop through each record, parsing the concatenated address field into separate fields for street, city, state, and zip.
You might use string manipulation functions like RAT(), SUBSTR(), and AT() to split the address field based on delimiters (like commas and spaces).
Create and Populate the .DBF File:

Define a .DBF file structure that includes fields for street, city, state, and zip.
As you loop through the CSV records, populate these fields with the parsed data.
Use Harbour's DBF-related functions to create and write to the .DBF file.
Error Handling and Data Validation: Ensure your program can handle any irregularities in the data, such as missing fields or unusual formatting.

Since providing a complete Harbour program here is quite complex and depends on your specific data and environment, I'll outline a basic pseudocode to get you started:

harbour
Copy code
FUNCTION Main()

    // Open CSV file
    oCsv := CsvFileOpen("yourfile.csv")

    // Create a new DBF file
    DbCreate("output.dbf", {{"Street", "C", 100, 0}, {"City", "C", 50, 0}, {"State", "C", 50, 0}, {"Zip", "C", 20, 0}})

    // Process each row
    WHILE !oCsv:EOF()
        cLine := oCsv:ReadLine()
        aFields := StrSplit(cLine, ',') // Split line into fields

        // Assuming the concatenated address is in the first field
        aAddress := ParseAddress(aFields[1])

        // Add record to DBF
        DbAppend()
        Replace Street WITH aAddress[1]
        Replace City   WITH aAddress[2]
        Replace State  WITH aAddress[3]
        Replace Zip    WITH aAddress[4]

        oCsv:Skip()
    ENDDO

    RETURN NIL
ENDFUNCTION

FUNCTION ParseAddress(cAddress)
    // Implement your logic to split the address string into its components
    // Return an array with [Street, City, State, Zip]
    // ...
ENDFUNCTION
In this pseudocode:

CsvFileOpen and StrSplit would be custom functions you write to handle CSV processing.
ParseAddress is a placeholder for your logic to split the address into separate fields.
Remember, Harbour's capabilities for string manipulation and file handling are more limited compared to languages like Python. If you have the flexibility to use a combination of tools, processing the Excel file in Python and then using Harbour for the database operations might be more efficient.

User
please write these, too
ChatGPT
Certainly! To complete the Harbour script, I'll provide implementations for the CsvFileOpen, StrSplit, and ParseAddress functions mentioned in the pseudocode. Keep in mind that Harbour doesn't natively support CSV parsing like modern programming languages, so these functions will be somewhat basic and may need adjustments based on the specific format of your CSV file.

1. CsvFileOpen Function
This function will open a CSV file for reading. It returns an object that keeps track of the file handle and provides methods to read and check for the end of the file (EOF).

harbour
Copy code
FUNCTION CsvFileOpen(cFileName)
    LOCAL oCsv := {}

    oCsv := { hb_fopen(cFileName, FO_READ), 0 }

    oCsv.Readline := {|o| CsvReadLine(o) }
    oCsv.EOF := {|o| hb_feof(o[1]) }
    oCsv.Skip := {|o| o[2]++ }

    RETURN oCsv
ENDFUNCTION

FUNCTION CsvReadLine(oCsv)
    LOCAL cLine := ""
    IF !hb_feof(oCsv[1])
        cLine := hb_fgets(oCsv[1], 8192)
        oCsv[2]++
    ENDIF
    RETURN cLine
ENDFUNCTION
2. StrSplit Function
This function will split a string into an array based on a delimiter. It's a simple version and does not handle edge cases like quoted delimiters.

harbour
Copy code
FUNCTION StrSplit(cString, cDelimiter)
    LOCAL aArray := {}
    LOCAL nStart := 1
    LOCAL nFound := hb_at(cDelimiter, cString)

    DO WHILE nFound > 0
        AADD(aArray, hb_substr(cString, nStart, nFound - nStart))
        nStart := nFound + LEN(cDelimiter)
        nFound := hb_at(cDelimiter, cString, nStart)
    ENDDO

    AADD(aArray, hb_substr(cString, nStart))
    RETURN aArray
ENDFUNCTION
3. ParseAddress Function
This function will split the concatenated address string into its components. It's a basic implementation and assumes that your addresses are formatted consistently.

harbour
Copy code
FUNCTION ParseAddress(cAddress)
    LOCAL aAddress := {}
    LOCAL nPos

    // Splitting based on the assumption that the format is "Street, City, State ZIP"
    nPos := RAT(",", cAddress) // Find the last comma
    aAddress[1] := hb_substr(cAddress, 1, nPos - 1) // Street
    cAddress := hb_substr(cAddress, nPos + 1)

    nPos := RAT(" ", cAddress) // Assuming the last space before ZIP
    aAddress[2] := hb_substr(cAddress, 1, nPos - 1) // City
    aAddress[3] := hb_substr(cAddress, nPos + 1, 2) // State
    aAddress[4] := hb_substr(cAddress, nPos + 4) // ZIP

    RETURN aAddress
ENDFUNCTION
Notes and Recommendations:
These functions are basic and may need to be adapted for more complex or irregular data formats.
Error handling and edge cases (like missing data or unusual formatting) should be considered for a robust solution.
If your CSV contains quotes around fields or escaped characters, additional logic will be needed to handle these cases.
The efficiency and performance of these functions may not be optimal for very large files.
This code provides a foundational approach to your task in Harbour. For more complex or varied data, you might need to employ more sophisticated parsing and error handling strategies.

[frose]

Very interesting and fascinating.
If you ask "... And fivewin" then the answer is very different:

To convert an Excel worksheet containing addresses with columns for Street, City, State, and Zip to a SQL table using Harbour and FiveWin, you can follow these steps:

1. Load the Excel file: Use the appropriate library or functions in Harbour to load the Excel file. You may choose to use libraries like XLSXREAD or Office Automation Libraries to read Excel files.

2. Parse the Excel data: Extract the data from the Excel file, specifically from the worksheet that contains the addresses. You can iterate over the rows and columns of the Excel file to retrieve the relevant data.

3. Connect to the database: Use the appropriate database connectivity library for Harbour (e.g., HbMySQL, HbSQLite, etc.) to establish a connection to your desired SQL database.

4. Create the SQL table: Define the structure of the table to hold the address information. You can generate an SQL statement to create a table with columns for Street, City, State, and Zip. Here's an example SQL statement for creating a table:

```sql
CREATE TABLE IF NOT EXISTS Addresses (
Street VARCHAR(255),
City VARCHAR(100),
State VARCHAR(50),
Zip VARCHAR(20)
);
```

5. Insert data into the SQL table: Iterate over the data you extracted from the Excel file and generate SQL INSERT statements to populate the table. You can use SQL commands like INSERT INTO to add records to the table. Here's an example:

```sql
INSERT INTO Addresses (Street, City, State, Zip) VALUES ('123 Main St', 'Cityville', 'CA', '12345');
```

6. Execute the SQL statements: Use the appropriate functions from the Harbour database library to execute the SQL statements. This will insert the address data into the SQL table.

7. Close the connection: Once all the data has been inserted, close the connection to the SQL database to free up resources.

By following these steps, you should be able to convert the Excel worksheet containing addresses into a SQL table using Harbour and FiveWin. Remember to adapt the code to the specific libraries and database systems you are using.

[Marc Venken]

Dear Rick,

Code: Select all  Expand view  RUN

#include "FiveWin.ch"

function Main()

   local cAddress := "258 Shoreline Drive, Columbia, SC 29212"
   
   XBrowse( hb_ATokens( cAddress, "," ) )

return nil

I prefer to ask the forum... Always the best answers