 table of MySQL as a blob, or maybe a separate
images table with a unique id, and just store the appropriate image id in the
users table, or simply save the uploaded file on the server (via an upload page as well) and save the file as
theUsersUniqueUsername.jpg.
Best option?
I found a tutorial on saving images to mysql here:
I am only a hobby programmer, and haven’t ever done anything like this before, so examples, and/or a lot of detail is greatly appreciated.
Always depends of context, but usually, I store a user image on the filesystem in a folder called
/content/user/{user_id}.jpg and try to bother the database as little as possible.
Answer：
I would recommend storing the image as a file and then have the file URI in the database. If you store all the images in the database, you might have some problems with scaling at a later date.
Microsoft’s advice for SQL Server used to be, for speed and size, store images in the file system, with links in the database. I think they’ve softened their preference a bit, but I still consider it a better idea certainly for size, since it will take up no space in the database.
Answer：
The overhead using BLOB is a lot less than most people would have you believe, especially if you set it up right. If you use a separate server just running the DB to store binary files then you can in fact use no file-system at all and avoid any overhead from the file-system
That said the easiest/best way unless you have a couple of servers to yourself is storing them in the filesystem
Do not store the absolute URL of the file in your DB, just the unique part (and possibly a folder or two), e.g.
2009/uniqueImageName.jpgor just
uniqueImageName.jpg.
Then in your pages just add the host and other folders onto the front, that way you have some flexibility in moving your images – all you’ll need to change is a line or two in your PHP/ASP.NET page.
There is no need to store outside the document root for security – a
.htaccessfile with DENY FROM ALL will work the same and provide more flexibility
No need to ‘shunt’ images so much for security, just have a
getImage.phppage or something, and then instead of inserting the actual URL in the
srcof the
image, use something like
getImage.php?file=uniqueImageName.jpg.
Then the
getImage.phpfile can check if the user is authorised and grab the image (or not).
Use a name which is guaranteed to be unique (preferably an integer i.e. primary key) when storing, some file-system (i.e. Windows) are case-insensitive, so
JoeBloggs.jpgand
joebloggs.jpgare unique for the database, but not for the file-system so one will overwrite another.
Use a separate table for the images, and store the primary key of the image in the users table. If you ever want to add more fields or make changes in future it will be easier – it’s also good practice.
If you are worried about SEO and things like that, store the image’s original file name in another field when you are uploading, you can then use this in your output (such as in the
alt tag).
Answer：
Challenging the Conventional Wisdom!
Of course it is context dependent, but I have a very large application with thousands of images and documents stored as BLOBS in a MySQL database (average size=2MB) and the application runs fine on a server with 256MB of memory. The secret is correct database structure. Always keep two separate tables, one of which stores the basic information about the file, and the other table should just contain the blob plus a primary key for accessing it. All basic queries will be run against the details table, and the other table is only access when the file is actually needed, and it is accessed using an indexed key so performance is extremely good.
The advantages of storing files in the database are multiple:
- Much easier backup systems are required, as you do not need to back up the file system
- Controlling file security is much easier as you can validate before releasing the binary (yes, you can store the file in a non-public directory and have a script read and regurgitate the file, but performance will not be noticeably faster.
- (Similar to #1) It cleanly separates “user content” and “system content”, making migrations and cloning easier.
- Easier to manage files, track/store version changes, etc, as you need fewer script modifications to add version controls in.
If performance is a big issue and security and backups aren’t (or if you have a good fs backup system) then you can store it the the FS, but even then I often store files (in the case of images) in the DB and building a caching script that writes the image to a cache folder after the first time it’s used (yes, this uses more HD space, but that is almost never a limiting factor).
Anyway, obviously FS works well in many instances, but I personally find DB management much easier and more flexible, and if written well the performance penalties are extremely small.
Answer：
We created a shop that stored images in the DB. It worked great during development but once we tested it on the production servers the page load time was far too high, and it added unneccessary load to the DB servers.
While it seems attractive to store binary files in the DB, fetching and manipulating them adds extra complexity that can be avoided by just keeping files on the file system and storing paths / metadata in the DB.
This is one of those eternal debates, with excellent arguments on both sides, but for my money I would keep images away from the DB.
Answer：
I recently saw this tip’s list:
Tip 17:
For your web application, images and other binary assets should normally be stored as files. That is, store only a reference to the file rather than the file itself in the database.
So just save the file path to the image 🙂
Answer：
I have implemented both solutions (file system and database-persisted images) in previous projects. In my opinion, you should store images in your database. Here’s why:
- File system storage is more complicated when your app servers are clustered. You have to have shared storage. Even if your current environment is not clustered, this makes it more difficult to scale up when you need to.
- You should be using a CDN for your static content anyways, and set your app up as the origin. This means that your app will only be hit once for a given image, then it will be cached on the CDN. CloudFront is dirt cheap and simple to set up…there’s no reason not to use it. Save your bandwidth for your dynamic content.
- It’s much quicker (and thus cheaper) to develop database persisted images
- You get referential integrity with database persisted images. If you’re storing images on the file system, you will inevitably have orphan files with no matching database records, or you’ll have database records with broken file links. This WILL happen…it’s just a matter of time. You’ll have to write something to clean these up.
Anyways, my two cents.
Answer：
- What’s the blob datatype for anyway, if not for storing files?
- If your application involves authorisation prior to accessing the files, the changes are that you’re a) storing the files outside of DOCUMENT_ROOT (so they can’t be accessed directly; and possibly b) sending the entire contents of the files through the application (of course, maybe you’re doing some sort of temporarilly-move-to-hashed-but-publicly-accessible-filename thing). So the memory overhead is there anyway, and you might as well be retrieving the data from the database.
- If you must store files in a filesystem, do as Andreas suggested above, and name them using something you already know (i.e. the primary key of the relevant table).
Answer：
I think that most database engines are so advanced already that storing BLOB’s of data does not produce any disadvantages (bloated db etc). One advantage is that you don’t have any broken links when the image is in the database already. That being said, I have myself always done so that I store the file on disk and give the URI to the database. It depends on the usage. It may be easier to handle img-in-db if the page is very dynamic and changes often – no namespace -problems. I have to say that it ends down to what you prefer.
Answer：
I would suggest you do not store the image in your db. Instead since every user will be having a unique id associated with his/her profile in the db, use that id to store the image physically on the server.
e.g. if a user has id 23, you can store an image in. Then to display, you can check if the image exists, and display it accordingly else display your generic icon.
Answer：
As the others suggested:
- Store the images in the filesystem
- Do not bother to store the filename, just use the user id (or anything else that “you already know”)
- Put static data on a different server (even if you just use “static.yourdomain.com” as an alias to your normal server)
Why ?
The bigger your database gets the slower it will get.
Storing your image in the database will increase your database size.
Storing the filename will increase your database size.
Putting static data on a different server (alias):
- Makes scaling up a lot easier
- Most browsers will not send more than two requests to the same server, by putting static data on a “second” server you speed up the loading
Answer：
After researching for days, I made a system storing images and binaries on the database.
It was just great. I have now 100% control over the files, like access control, image sizing (I don’t scale the images dynamically, of course), statistics, backup and maintenance.
In my speed tests, the sistem is now 10x slower. However, it’s still not in production and I will implement system cache and other optimizations.
Check this real example, still in development, on a SHARED host, using a MVC:
In this example, if a user is logged, he can see different images. All products images and others binaries are in DB, not cached, not in FS.
I have made some tests in a dedicated server and results were so far beyond the expectations.
So, in my personal opinion, although it needs a major effort to achieve it, storing images in DB is worth and the benefits are worth much more the cons.
Answer：
As everybody else told you, never store images in a database.
A filesystem is used to store files -> images are files -> store them in filesystem 🙂
Answer：
Just tested my img’s as blob, so. This solution working slower than images on server as file. Loading time should be same with images from DB or http but is’t. Why? Im sure, when images are files on server, browser can caching it and loading only once, first time. When image going form DB, every time is loaded again. That’s my oppinion. Maybe Im wrong about browser caching, but working slower (blob). Sry my English, whatever ;P
Answer：
These are the pros of both solutions
In BLOBS :
1) pros : the easiness to mange clusters since you do not have to handle tricky points like file syncs between servers
2) DB backups will be exhaustive also
In files
1) Native caching handly (and that’s the missing point of previous comments, with refresh and headers that you won’t have to redesign in DB (DB are not handling last modification time by default)
2) Easiness of resizing later on
3) Easiness of moderation (just go through your folders to check if everything is correct)
For all these reasons and since the two pros of databases are easier to replicate on file system I strongly recommend files !
Answer：
In my case, i store files in file system. In my images folder i create new folder for each item named based on item id (row from db). And name images in an order starting from 0. So if i have a table named Items like this:
Items |-----|------|-----| | ID | Name | Date| |-----|------|-----| | 29 | Test1| 2014| |-----|------|-----| | 30 | Test2| 2015| |-----|------|-----| | 31 | Test3| 2016| |-----|------|-----|
my images directory looks like something like:
images/ 29/ 30/ 31/ images/29/0.png images/29/1.jpeg images/29/2.gif
etc.
Tags: image, mysql, phpphp, sql