C# Parser for SQL Migrations

@AwaisChaudhry

Hello, I understand you need a lightweight C# parser that scans VB.NET code for embedded SQL migrations and converts each detected change into a strongly-typed C# class. The focus is on table creation and updates, extracting full table schema details, each column’s type and constraints, index definitions, and defaults, and normalizing identifiers for consistency. I will deliver a small .NET 8/10 library (C# 8+ style) that reads a text file, pulls out the SQL strings, recognizes operations like ALTER TABLE ADD COLUMN, ADD CONSTRAINT, CREATE TABLE, CREATE INDEX, and DROP COLUMN, and outputs a deterministic, readable collection of structured objects. The library will be unit-tested with MSTest, ensuring end-to-end parsing for at least one create and one update script, with tests validating the generated class names and properties. Approach: Use lightweight parsing with regular expressions to extract SQL strings from VB code, then apply targeted parsers per operation to fill strongly-typed objects (Table, Operation, Column, Type, Default, Index). Normalize identifiers by stripping brackets, trimming, and uppercasing for consistency. The module will not attempt to execute SQL or interpret VB control flow, only extract and structure the SQL pieces. The output will be a small, dependency-free library ready for expansion to stitch together SQL code later. What is the expected naming convention for the generated C# classes and properties (e.g., PascalCase, how to handle reserved wo

@shrec

Hi, I can develop a lightweight C# library that scans VB .NET source files, extracts embedded SQL statements related to table creation and updates, and generates strongly-typed C# classes representing full table schemas, columns, constraints, indexes, and default values. The parser will normalize identifiers, identify key SQL operations (CREATE TABLE, ALTER TABLE, CREATE INDEX, etc.), and produce structured, deterministic, and readable classes. I’ll also deliver a complete MSTest project that validates parsing against sample scripts, ensuring dotnet test passes on the first run. The library will be self-contained, using only standard .NET libraries, ready for future expansion to parse SQL across your entire VB codebase.

@ZohaibRoy

⭐⭐⭐⭐⭐ Create a C# Parser for VB .NET SQL Migration Tasks ❇️ Hi My Friend, I hope you're doing well. I've reviewed your project needs and see you're looking for a C# parser to handle VB .NET SQL migration tasks. Look no further; Zohaib is here to help you! My team has successfully completed 50+ similar projects, focusing on creating efficient parsers. I will analyze the legacy files, extract SQL statements, and convert them into structured C# classes, ensuring all details are captured effectively. ➡️ Why Me? I can easily create your parser as I have 5 years of experience in C# development, specializing in parsing and data extraction. My skills include SQL manipulation, object-oriented programming, and code optimization. I also have a strong grip on .NET libraries and MSTest, which will be essential for your project. ➡️ Let's have a quick chat to discuss your project in detail and let me show you samples of my previous work. Looking forward to discussing this with you in chat. ➡️ Skills & Experience: ✅ C# Development ✅ SQL Parsing ✅ Object-Oriented Programming ✅ Data Extraction ✅ Code Optimization ✅ MSTest Framework ✅ .NET Libraries ✅ Regular Expressions ✅ Source Code Analysis ✅ Error Handling ✅ Version Control (Git) ✅ Legacy Code Understanding Waiting for your response! Best Regards, Zohaib

@juanjosec63

Hi, I can help you develop a lightweight C# parser that scans your legacy VB .NET source files, extracts embedded SQL statements, and converts them into strongly-typed C# classes. The classes will represent the table schema, column data types, constraints, and indexes, capturing the SQL migration tasks related to table creation and updates. The parser will: Extract SQL strings from VB code using Regular Expressions. Detect SQL operations like ALTER TABLE, CREATE TABLE, and CREATE INDEX. Normalize SQL identifiers (e.g., stripping brackets and unifying casing). Produce a structured C# object model for each migration task, including details such as the table name, operation type, columns, and their constraints. I will also create an MSTest project to validate the parser, ensuring it reads a sample input file, processes it correctly, and generates the expected structured C# output. The library will be built with C# 8/10 and .NET standard libraries to minimize external dependencies. I estimate the project can be delivered within 1-2 weeks, with tests covering at least one create and one update script to ensure accurate parsing. Best regards, Juan

@artakharutyun7

Hi, I’ve reviewed the requirements and can deliver a lightweight, deterministic parser in modern C# (C# 10) that extracts and structures embedded SQL from legacy VB.NET code. My approach: • Use regex/token-based extraction to isolate SQL strings from VB without full VB parsing • Implement a focused SQL parser for DDL operations (ALTER TABLE, CREATE TABLE, CREATE INDEX, constraints, defaults) • Normalize identifiers (brackets, casing) and map to strongly-typed C# models • Ensure deterministic class/property naming for downstream model generation • Provide clean separation between extraction, parsing, and model layers I will deliver: • A small .NET library that reads VB source, extracts SQL, and outputs structured objects • Coverage for column definitions, constraints, defaults, and indexes • An MSTest project with end-to-end tests (create + alter scenarios) passing via `dotnet test` I’ve built similar code analysis and transformation tools and am confident in handling this efficiently while keeping the implementation simple, maintainable, and extensible for future expansion. Happy to start immediately and iterate based on real sample inputs. Best regards, Artak

@justinw45

Hello, I understand the need for a C# parser that can efficiently scan legacy VB .NET source files, extract SQL migration tasks related to table creation and updates, and convert them into structured C# classes representing table schemas, column data types, constraints, index definitions, and default values. The main goal is to create a reliable source of truth for schema changes within the workplace. My approach involves developing a lightweight C# library that can accurately extract SQL strings from VB code, identify various SQL operations, normalize identifiers, and produce structured C# representations of the schema elements specified. The deliverable will be a C# 8 or 10 library/script along with an MSTest project to validate the parsing accuracy. I am ready to start working on this project immediately and would welcome further discussion to clarify any additional requirements, scope details, and expectations. Best regards, Justin

@mohjib092

Hi, I can build a lightweight, modern C# parser to extract and structure SQL schema changes from your legacy VB .NET code exactly as you described. If you like, I can deliver a working prototype parser for one sample ALTER and CREATE table script first, so you can verify the output before we complete the full library

@jeanpatrickr8

Hello, I appreciate the opportunity to work on your project involving the creation of a C# parser for legacy VB .NET source files. I understand that you need a lightweight tool to extract and convert embedded SQL migration tasks into strongly-typed C# classes, focusing on table creation and updates. With over five years of experience in C# development, I have successfully built parsers and tools that analyze and transform codebases. My expertise in regular expressions and string manipulation will allow me to effectively extract SQL statements and normalize identifiers as specified. To achieve your project goals, I propose the following approach: - Develop a C# library that reads the provided text file and identifies relevant SQL operations. - Implement robust parsing logic to convert SQL statements into structured C# objects, ensuring clarity and compliance with your requirements. - Create an MSTest project to validate the parsing accuracy and ensure the generated classes reflect the desired schema elements. I am excited about the possibility of contributing to your project and am confident in my ability to deliver quality results on time. I am available to discuss any further details and can start immediately. Thank you for considering my proposal!

@HiraMahmood4072

Hello, With over 7 years of experience in VB.NET, Data Modeling, SQL, .NET, and Database Design, I have carefully reviewed the requirements for your project. To tackle the task at hand, I propose developing a lightweight C# parser that will scan the legacy VB .NET source files, identify and extract SQL migration tasks related to table creation and updates, and convert them into structured C# classes. These classes will represent the full table schema, column data types, constraints, index definitions, and default values. The parser will normalize identifiers, extract SQL strings, and produce a structured representation as per the specified output format. The deliverable will be a C# library or script that reads the input text file, extracts and parses SQL statements, and generates structured C# classes. Additionally, an MSTest project will be included to validate the accuracy of the generated classes. I would be happy to discuss this project further in chat to address any questions or concerns you may have. You can visit my profile at https://www.freelancer.com/u/HiraMahmood4072 Thank you.

@billybryan98

Hello, I hope you are doing well. I’m an independent C# developer with a focused background in data modeling, parsing, and .NET tooling. I love turning legacy code patterns into clean, strongly-typed representations, and I’ll approach your VB.NET embedded-SQL task with that mindset: extract SQL safely, normalize identifiers, and output a precise C# model that reflects the full table schema, columns, types, constraints, defaults, and indexes. I’ve built lightweight parsers and DSL-like mappers in C# using regular expressions, string normalization, and robust data modeling. I will create a small C# 8/10 library that reads a text file, extracts SQL strings from VB code, recognizes operations such as ALTER TABLE ADD COLUMN, ADD CONSTRAINT, CREATE TABLE, and more, and emits strongly-typed objects. Tests will cover at least one create and one update script, with deterministic, readable class names, all without external dependencies. I can deliver a ready-to-run MSTest project and sample data, with clear, deterministic outputs, and a straightforward timeline. The Best regards, Billy Bryan

@natanr28

Hello, I hope you're doing well. I understand you're looking for an efficient C# parser to handle SQL migrations from legacy VB .NET source files. This is essential as it will streamline the process of converting embedded SQL tasks into strongly-typed C# classes, ensuring your migration code remains the definitive source of truth in your workplace. I have extensive experience in modern C#, which enables me to write a parser that specifically extracts SQL statements, identifies various operations, and normalizes identifiers as per your requirements. The structured representation of schema changes will be developed to reflect the exact details you need, such as table definitions and constraints. I can deliver a lightweight library that meets your acceptance criteria and passes the test suite seamlessly. I'd like to have a chat with you at least so I can demonstrate my abilities and prove that I'm the best fit for this project. Warm regards, Natan.

@blackrockwise

Hello, I understand you need a lightweight modern C# parser to scan legacy VB .NET files and convert embedded SQL migration tasks into strongly-typed C# classes representing table schemas, columns, indexes, and default values. The parser should extract SQL strings, identify operations like ALTER TABLE, CREATE TABLE, CREATE INDEX, and more, normalize identifiers, and output structured representations without executing SQL or handling complex edge cases. With extensive experience in C# and building parsers for SQL and legacy codebases, I am confident I can deliver a clean, maintainable library compatible with C# 8 or 10. I will also create an MSTest project to ensure that your test cases pass consistently, supporting your goals of deterministic and readable class naming, and restricting dependencies to .NET standard libraries and MSTest. I am committed to delivering this within two weeks, maintaining clear communication throughout. This solution will position you well for further parser enhancements to consolidate SQL code across your legacy application. Please feel free to reach out so we can discuss your requirements further and start on a solid plan to build this reliable migration parser for you.

@Hemantt841

Hello, I see you need a lightweight C# parser to extract and convert embedded SQL migration tasks from legacy VB .NET source files into strongly-typed C# classes. Your focus on table creation and update statements as the single source of truth for schema changes is clear. You require the parser to handle SQL extraction from VB code, identify specific operations like ALTER TABLE ADD COLUMN and CREATE INDEX, normalize identifiers, and produce structured C# representations. The deliverable includes a C# 8 or 10 library plus an MSTest project verifying the parser with no external dependencies beyond .NET and MSTest. I have built similar parsers that extract SQL from code files using regular expressions and string parsing, then modeled complex database schema changes into C# classes with clear property mappings. I delivered lightweight libraries that run MSTest suites to validate parsing correctness and property naming conventions, which aligns well with your acceptance criteria. I can deliver the initial parser and test suite within 10 working days. Let me know if you want to discuss the implementation details or sample inputs to ensure we meet your expectations fully.

@craigd43

Having worked extensively with C# throughout my career, I believe I am the perfect match for your project. My ability to write clean, efficient, and modern C# code aligns perfectly with your need for a lightweight parser. Using my expertise in C#, I can design and implement a parser that seamlessly extracts SQL statements from the VB code while filtering out any logic that is not necessary for your task. Moreover, given my background in full-stack web development and web scraping, I am adept at handling complex parsing tasks and normalizing different types of identifiers. Creating structured representations of data is something I have done numerous times before, making me the right person to generate well-structured C# classes based on your desired model. Lastly, as your project expands to incorporate more SQL code throughout the legacy VB .NET application, I will be there every step of the way. I am careful about not just writing good code, but also sustainable and scalable code - this would prove invaluable as we handle edge cases and adapt the parser to new challenges. Let's get to work!

@jonhw5

Hello, thanks for posting this project. I can design and deliver a lightweight C# parser that scans VB.NET sources, extracts embedded SQL, and transforms each relevant statement into strongly-typed C# objects that mirror the requested table and column metadata. My approach emphasizes deterministic naming, robust parsing with regex and simple tokenization, and strict typing for Table, Column, Type, Default, and Index data. I will produce a small .NET 8 (C# 8/10 compatible) library plus an MSTest project to validate end-to-end parsing with both creation and update scripts. Input extraction will normalize identifiers (strip brackets, unify casing) and focus on the supported operations (ALTER TABLE ADD, CREATE TABLE, CREATE INDEX, DROP COLUMN, etc.). The deliverable will include: - a library that reads a text file and emits a collection of structured C# objects; - tests that load sample VB code, parse SQL, and assert the generated schema elements faithfully reflect the input; - no external dependencies beyond standard .NET libraries. What naming conventions would you prefer for generated class and property names to ensure readability and deterministic output across your VB.NET source suite? Looking forward to discussing how you want the generated class naming to handle edge cases and any naming conventions you prefer. Best regards,

@kuldeepsharma30

Hi there Most developers will try to “parse SQL” broadly and overcomplicate this. Your requirement is narrower — extract, normalize, and model only migration-relevant statements reliably. I have built parsers for legacy codebases where SQL inside application code was the only source of truth, so precision + determinism mattered more than completeness. My approach: * Extract SQL strings from VB using lightweight pattern matching (no VB parsing overhead) * Build a focused parser for target statements (ALTER, CREATE, INDEX, DROP) using tokenization + rule-based parsing * Normalize identifiers (strip brackets, consistent casing) before modeling * Map outputs into strongly-typed C# classes (clear, deterministic naming) * Cover with MSTest cases to validate create + update flows end-to-end Key point: instead of a generic SQL parser, I will design a migration-aware parser tuned to your patterns, which keeps it lightweight and extensible. No external dependencies — pure .NET + MSTest. Before I finalize structure: Do your SQL statements follow consistent formatting patterns, or should the parser be tolerant to variations (line breaks, concatenated strings, dynamic SQL)?

@omarfranciscoa

Hello! How are you doing? I had a look at your job description and it sounds like something I can definitely help you with. I have strong experience in C#, VB.NET, SQL Server, and building lightweight code analyzers and parsers, so I feel very comfortable handling a project that scans legacy VB .NET sources for embedded SQL migrations and outputs strongly-typed C# representations. I will deliver a compact C# 8/10 library that reads a text file, extracts SQL statements, normalizes identifiers, recognizes operations (ALTER TABLE ADD COLUMN, ADD CONSTRAINT, CREATE TABLE, CREATE INDEX, DROP COLUMN, etc.), and parses them into deterministic, readable C# classes that expose the full table schema, column data types and constraints, index definitions, and default values. The deliverables will include the library plus an MSTest project that exercises at least one creation and one update script end-to-end, ensuring dotnet test passes on the first run. I’ll structure the output classes to reflect a clear, strongly-typed model suitable for updating a conceptual model from the migration code itself. Please feel free to share sample VB snippets or preferred naming conventions if you have them, and I’ll tailor the class naming strategy accordingly. Thank you and I look forward to hearing from you! Best regards,

@juanestebana17

Hi, With extensive experience in C# development and SQL parsing, I will create a lightweight parser that efficiently extracts and converts SQL migration tasks within VB.NET source files into strongly-typed C# classes, maintaining clarity and accuracy. How do you envision handling complex or nested SQL statements in your legacy VB.NET code? Thanks,

@tarast7

Hello, How are you? I have reviewed your job description and I'm confident in my ability to deliver precisely what you require. With my extensive experience in C# programming and SQL, I believe this project is a perfect match for my skills and expertise. Through a lightweight C# parser, I will efficiently scan and convert legacy VB .NET source files containing SQL migration tasks into structured C# classes representing table schemas, column details, index definitions, and more. By creating a parser that analyzes SQL operations and extracts essential data, I aim to provide you with a reliable solution for updating your conceptual model based on the migration code. Please reach out to me so we can discuss this further. Thanks! Taras